diff --git a/README.md b/README.md
index ad49e52..eea67ec 100644
--- a/README.md
+++ b/README.md
@@ -12,6 +12,7 @@ The BSV Wallet Toolbox builds on the [SDK](https://bsv-blockchain.github.io/ts-s
 - [Objective](#objective)
 - [Examples](#examples)
 - [Documentation](#documentation)
+- [Testing](#testing)
 - [Contribution Guidelines](#contribution-guidelines)
 - [Support \& Contacts](#support--contacts)
 - [License](#license)
@@ -25,7 +26,88 @@ The BSV Wallet Toolbox Examples provides a collection of self-contained sample c
 [The Docs](https://bsv-blockchain.github.io/wallet-toolbox) are available here on Github pages.  
 [Example code](https://docs.bsvblockchain.org/guides/sdks/ts/examples) is available over on our gitbook.  
 
-The Toolbox is richly documented with code-level annotations. This should show up well within editors like VSCode.  
+The Toolbox is richly documented with code-level annotations. This should show up well within editors like VSCode.
+
+
+## Testing
+
+### Running Tests
+
+To run the test suite:
+```bash
+npm test
+```
+
+For development with watch mode:
+```bash
+npm run test:watch
+```
+
+### Live Testing with Real Funds
+
+The Python storage server tests (`brc100.py.test.ts`) support live testing with real testnet funds. This allows you to verify that transactions are properly broadcasted and confirmed on the testnet blockchain.
+
+#### Setup for Live Testing
+
+1. **Generate a Testnet Key**
+   ```bash
+   npm run keygen
+   ```
+   This will output a new private key and testnet address. The private key should be added to your `.env` file.
+
+2. **Fund the Address**
+   Copy the testnet address and fund it using one of these faucets:
+   - [MoneyButton Testnet Faucet](https://testnetfaucet.moneybutton.com/)
+   - [Whatsonchain Testnet Faucet](https://faucet.whatsonchain.com/)
+   - [Mempool Testnet Faucet](https://testnet-faucet.mempool.space/)
+
+   You'll need at least 10 satoshis to run the transaction tests.
+
+3. **Configure Environment**
+   Add the generated private key to your `.env` file:
+   ```bash
+   LIVE_PRIVATE_KEY=your_generated_private_key_here
+   ```
+
+4. **Fund the Address**
+   Send testnet funds to the generated address using one of the faucets listed above.
+
+5. **Start the Python Storage Server**
+   Make sure the Python storage server is running:
+   ```bash
+   cd ../py-wallet-toolbox/examples/storage_server_example
+   python manage.py runserver
+   ```
+
+6. **Run Live Tests**
+   The tests will automatically detect your funded address and attempt to internalize the funding transaction:
+   ```bash
+   npm run test:py:live
+   ```
+
+   **Note**: Transaction internalization requires Atomic BEEF format. If automatic internalization fails, you can manually run:
+   ```bash
+   npm run internalize-funding
+   ```
+   ```bash
+   npm run test:py:live
+   ```
+
+#### What Live Testing Does
+
+- Uses your funded testnet key instead of development keys
+- Broadcasts real transactions to the testnet blockchain
+- Verifies transaction confirmations and balance updates
+- Provides links to view transactions on blockchain explorers
+
+**⚠️ WARNING**: Live testing uses real testnet funds. While testnet coins have no monetary value, they still cost gas fees and should be used responsibly.
+
+#### Test Scripts
+
+- `npm run keygen` - Generate a new testnet key and address
+- `npm run internalize-funding` - Manually internalize funding transaction into wallet (if auto-internalization fails)
+- `npm run test:py` - Run Python storage server tests in test mode (no broadcasting)
+- `npm run test:py:live` - Run Python storage server tests in live mode with automatic funding detection
 
 
 ## Examples
diff --git a/debug_brc104_nonces.js b/debug_brc104_nonces.js
new file mode 100644
index 0000000..1346607
--- /dev/null
+++ b/debug_brc104_nonces.js
@@ -0,0 +1,44 @@
+const { Setup } = require('@bsv/wallet-toolbox');
+const { Peer, SimplifiedFetchTransport } = require('@bsv/sdk');
+
+async function debugNonces() {
+  const env = Setup.getEnv('test');
+  const rootKeyHex = env.devKeys[env.identityKey];
+  
+  const setup = await Setup.createWallet({
+    env,
+    rootKeyHex
+  });
+  
+  console.log('Client Identity:', env.identityKey);
+  
+  // Create transport and peer
+  const transport = new SimplifiedFetchTransport('http://localhost:8000');
+  const peer = new Peer(setup.wallet, transport);
+  
+  // Intercept the send method to log what's being sent
+  const originalSend = transport.send.bind(transport);
+  transport.send = async function(message) {
+    if (message.messageType === 'general') {
+      console.log('\n[CLIENT] Sending general message:');
+      console.log('  nonce (request):', message.nonce);
+      console.log('  yourNonce (server nonce from handshake):', message.yourNonce);
+      console.log('  Expected keyID:', `${message.nonce} ${message.yourNonce}`);
+    }
+    return originalSend(message);
+  };
+  
+  try {
+    // This will trigger the handshake
+    const testPayload = Buffer.from(JSON.stringify({ method: 'test' }));
+    await peer.toPeer(Array.from(testPayload));
+    console.log('\n✅ Message sent successfully!');
+  } catch (error) {
+    console.error('\n❌ Error:', error.message);
+  }
+  
+  process.exit(0);
+}
+
+debugNonces().catch(console.error);
+
diff --git a/debug_signature.js b/debug_signature.js
new file mode 100644
index 0000000..9091758
--- /dev/null
+++ b/debug_signature.js
@@ -0,0 +1,55 @@
+const { PrivateKey } = require('@bsv/sdk');
+const { Setup } = require('@bsv/wallet-toolbox');
+
+async function debugSignature() {
+  const env = Setup.getEnv('test');
+  const rootKeyHex = env.devKeys[env.identityKey];
+  
+  console.log('Client Root Key:', rootKeyHex);
+  console.log('Client Identity Key:', env.identityKey);
+  
+  // Create wallet
+  const setup = await Setup.createWallet({
+    env,
+    rootKeyHex
+  });
+  
+  // Test data
+  const testData = Buffer.from('hello world');
+  const protocolID = [2, 'auth message signature'];
+  const keyID = 'nonce1 nonce2';
+  const counterparty = '0320295654f4c8d4d2bc2ed79b0169f7584e62519b17f6a829adebe400316c90d6'; // Server public key
+  
+  console.log('\n--- Creating Signature ---');
+  console.log('Data:', testData.toString('hex'));
+  console.log('ProtocolID:', protocolID);
+  console.log('KeyID:', keyID);
+  console.log('Counterparty:', counterparty);
+  
+  const sigResult = await setup.wallet.createSignature({
+    data: Array.from(testData),
+    protocolID,
+    keyID,
+    counterparty
+  });
+  
+  console.log('Signature:', Buffer.from(sigResult.signature).toString('hex'));
+  
+  // Now verify
+  console.log('\n--- Verifying Signature ---');
+  const verifyResult = await setup.wallet.verifySignature({
+    data: Array.from(testData),
+    protocolID,
+    keyID,
+    counterparty,
+    signature: sigResult.signature
+  });
+  
+  console.log('Verification result:', verifyResult.valid);
+  
+  process.exit(0);
+}
+
+debugSignature().catch(console.error);
+
+
diff --git a/debug_signature2.js b/debug_signature2.js
new file mode 100644
index 0000000..579165a
--- /dev/null
+++ b/debug_signature2.js
@@ -0,0 +1,67 @@
+const { PrivateKey } = require('@bsv/sdk');
+const { Setup } = require('@bsv/wallet-toolbox');
+
+async function debugSignature() {
+  const env = Setup.getEnv('test');
+  const rootKeyHex = env.devKeys[env.identityKey];
+  
+  console.log('Client Root Key:', rootKeyHex);
+  console.log('Client Identity Key:', env.identityKey);
+  
+  // Create wallet
+  const setup = await Setup.createWallet({
+    env,
+    rootKeyHex
+  });
+  
+  // Test data
+  const testData = Buffer.from('hello world');
+  const protocolID = [2, 'auth message signature'];
+  const keyID = 'nonce1 nonce2';
+  
+  console.log('\n--- Test 1: With counterparty="self" ---');
+  const sigResult1 = await setup.wallet.createSignature({
+    data: Array.from(testData),
+    protocolID,
+    keyID,
+    counterparty: 'self'
+  });
+  
+  console.log('Signature:', Buffer.from(sigResult1.signature).toString('hex'));
+  
+  const verifyResult1 = await setup.wallet.verifySignature({
+    data: Array.from(testData),
+    protocolID,
+    keyID,
+    counterparty: 'self',
+    signature: sigResult1.signature
+  });
+  
+  console.log('Verification result:', verifyResult1.valid);
+  
+  console.log('\n--- Test 2: With counterparty="anyone" ---');
+  const sigResult2 = await setup.wallet.createSignature({
+    data: Array.from(testData),
+    protocolID,
+    keyID,
+    counterparty: 'anyone'
+  });
+  
+  console.log('Signature:', Buffer.from(sigResult2.signature).toString('hex'));
+  
+  const verifyResult2 = await setup.wallet.verifySignature({
+    data: Array.from(testData),
+    protocolID,
+    keyID,
+    counterparty: 'anyone',
+    signature: sigResult2.signature
+  });
+  
+  console.log('Verification result:', verifyResult2.valid);
+  
+  process.exit(0);
+}
+
+debugSignature().catch(console.error);
+
+
diff --git a/package-lock.json b/package-lock.json
index 129ce8f..972cecb 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -9,7 +9,7 @@
       "version": "1.1.138",
       "license": "SEE LICENSE IN license.md",
       "dependencies": {
-        "@bsv/sdk": "^1.9.9",
+        "@bsv/sdk": "file:../ts-sdk",
         "@bsv/wallet-toolbox": "^1.7.13"
       },
       "devDependencies": {
@@ -35,6 +35,30 @@
         "typescript": "^5.2.2"
       }
     },
+    "../ts-sdk": {
+      "name": "@bsv/sdk",
+      "version": "1.9.29",
+      "license": "SEE LICENSE IN LICENSE.txt",
+      "devDependencies": {
+        "@eslint/js": "^9.39.1",
+        "@jest/globals": "^30.2.0",
+        "@rspack/cli": "^1.6.1",
+        "@rspack/core": "^1.6.1",
+        "@types/jest": "^30.0.0",
+        "@types/node": "^24.10.1",
+        "eslint": "^9.39.1",
+        "globals": "^16.5.0",
+        "jest": "^30.2.0",
+        "jest-environment-jsdom": "^30.2.0",
+        "ts-jest": "^29.4.5",
+        "ts-loader": "^9.5.4",
+        "ts-standard": "^12.0.2",
+        "ts2md": "^0.2.8",
+        "tsconfig-to-dual-package": "^1.2.0",
+        "typescript": "^5.9.3",
+        "typescript-eslint": "^8.46.4"
+      }
+    },
     "node_modules/@ampproject/remapping": {
       "version": "2.3.0",
       "resolved": "https://registry.npmjs.org/@ampproject/remapping/-/remapping-2.3.0.tgz",
@@ -80,7 +104,6 @@
       "integrity": "sha512-SRijHmF0PSPgLIBYlWnG0hyeJLwXE2CgpsXaMOrtt2yp9/86ALw6oUlj9KYuZ0JN07T4eBMVIW4li/9S1j2BGA==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@ampproject/remapping": "^2.2.0",
         "@babel/code-frame": "^7.26.2",
@@ -1271,10 +1294,8 @@
       }
     },
     "node_modules/@bsv/sdk": {
-      "version": "1.9.9",
-      "resolved": "https://registry.npmjs.org/@bsv/sdk/-/sdk-1.9.9.tgz",
-      "integrity": "sha512-bN90ULdrVJXokoWyF1Yw/sqtAns+T7CFAEA/J40RHKlHIkGN6Rb/ruWXGAL+rb1iJ/YzhnNs+y53dRdMCCkcxA==",
-      "license": "SEE LICENSE IN LICENSE.txt"
+      "resolved": "../ts-sdk",
+      "link": true
     },
     "node_modules/@bsv/wallet-toolbox": {
       "version": "1.7.13",
@@ -2186,7 +2207,6 @@
       "integrity": "sha512-/WndGO4kIfMicEQLTi/mDANUu/iVUhT7KboZPdEqqHQ4aTS+3qT3U5gIqWDFV+XouorjfgGqvKILJeHhuQgFYg==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "undici-types": "~6.19.2"
       }
@@ -2259,7 +2279,6 @@
       "integrity": "sha512-cl669nCJTZBsL97OF4kUQm5g5hC2uihk0NxY3WENAC0TYdILVkAyHymAntgxGkl7K+t0cXIrH5siy5S4XkFycA==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "bin": {
         "acorn": "bin/acorn"
       },
@@ -2910,7 +2929,6 @@
         }
       ],
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "caniuse-lite": "^1.0.30001688",
         "electron-to-chromium": "^1.5.73",
@@ -4006,7 +4024,6 @@
       "deprecated": "This version is no longer supported. Please see https://eslint.org/version-support for other options.",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@eslint-community/eslint-utils": "^4.2.0",
         "@eslint-community/regexpp": "^4.6.1",
@@ -4228,7 +4245,6 @@
       "integrity": "sha512-ixmkI62Rbc2/w8Vfxyh1jQRTdRTF52VxwRVHl/ykPAmqG+Nb7/kNn+byLP0LxPgI7zWA16Jt82SybJInmMia3A==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@rtsao/scc": "^1.1.0",
         "array-includes": "^3.1.8",
@@ -4293,7 +4309,6 @@
       "integrity": "sha512-jDex9s7D/Qial8AGVIHq4W7NswpUD5DPDL2RH8Lzd9EloWUuvUkHfv4FRLMipH5q2UtyurorBkPeNi1wVWNh3Q==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "builtins": "^5.0.1",
         "eslint-plugin-es": "^4.1.0",
@@ -4333,7 +4348,6 @@
       "integrity": "sha512-57Zzfw8G6+Gq7axm2Pdo3gW/Rx3h9Yywgn61uE/3elTCOePEHVrn2i5CdfBwA1BLK0Q0WqctICIUSqXZW/VprQ==",
       "dev": true,
       "license": "ISC",
-      "peer": true,
       "engines": {
         "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
       },
@@ -4350,7 +4364,6 @@
       "integrity": "sha512-BGP0jRmfYyvOyvMoRX/uoUeW+GqNj9y16bPQzqAHf3AYII/tDs+jMN0dBVkl88/OZwNGwrVFxE7riHsXVfy/LQ==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "array-includes": "^3.1.8",
         "array.prototype.findlast": "^1.2.5",
@@ -6416,7 +6429,6 @@
       "integrity": "sha512-NIy3oAFp9shda19hy4HK0HRTWKtPJmGdnvywu01nOqNC2vZg+Z+fvJDxpMQA88eb2I9EcafcdjYgsDthnYTvGw==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@jest/core": "^29.7.0",
         "@jest/types": "^29.6.3",
@@ -10015,7 +10027,6 @@
       "integrity": "sha512-f0FFpIdcHgn8zcPSbf1dRevwt047YMnaiJM3u2w2RewrB+fob/zePZcrOyQoLMMO7aBIddLcQIEK5dYjkLnGrQ==",
       "dev": true,
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "@cspotcode/source-map-support": "^0.8.0",
         "@tsconfig/node10": "^1.0.7",
@@ -10249,7 +10260,6 @@
       "integrity": "sha512-84MVSjMEHP+FQRPy3pX9sTVV/INIex71s9TL2Gm5FG/WG1SqXeKyZ0k7/blY/4FdOzI12CBy1vGc4og/eus0fw==",
       "dev": true,
       "license": "Apache-2.0",
-      "peer": true,
       "bin": {
         "tsc": "bin/tsc",
         "tsserver": "bin/tsserver"
diff --git a/package.json b/package.json
index 4723a10..d1f8a33 100644
--- a/package.json
+++ b/package.json
@@ -23,7 +23,10 @@
     "lint": "prettier --write 'src/**/*.ts' --log-level silent",
     "build": "tsc --build",
     "prepublish": "npm run lint && npm run build && npm run doc",
-    "doc": "ts2md"
+    "doc": "ts2md",
+    "keygen": "npm run build && npx tsx src/generateKey.ts",
+    "test:py": "npm run build && jest --testPathPattern=brc100.py.test.ts",
+    "test:py:live": "npm run build && LIVE=true jest --testPathPattern=brc100.py.test.ts"
   },
   "bugs": {
     "url": "https://github.com/bsv-blockchain/wallet-toolbox/issues"
@@ -52,7 +55,7 @@
     "typescript": "^5.2.2"
   },
   "dependencies": {
-    "@bsv/sdk": "^1.9.9",
+    "@bsv/sdk": "file:../ts-sdk",
     "@bsv/wallet-toolbox": "^1.7.13"
   }
 }
diff --git a/server.pid b/server.pid
new file mode 100644
index 0000000..b9fa543
--- /dev/null
+++ b/server.pid
@@ -0,0 +1 @@
+44724
diff --git a/src/brc100.go.test.ts b/src/brc100.go.test.ts
new file mode 100644
index 0000000..f13c192
--- /dev/null
+++ b/src/brc100.go.test.ts
@@ -0,0 +1,805 @@
+import { PrivateKey } from '@bsv/sdk'
+import { Setup, SetupWallet, StorageClient } from '@bsv/wallet-toolbox'
+
+/**
+ * Default go-wallet-toolbox endpoint URL.
+ */
+const DEFAULT_GO_WALLET_TOOLBOX_URL = 'http://localhost:8100'
+
+/**
+ * Track nosend transaction references for cleanup.
+ * Tests that create nosend transactions should add their references here.
+ */
+const pendingAborts: string[] = []
+
+describe('BRC-100 Wallet Operations (Go Storage Server)', () => {
+  let setup: SetupWallet
+  let walletServiceAvailable = false
+
+  beforeAll(async () => {
+    const endpointUrl =
+      process.env.GO_WALLET_TOOLBOX_URL || DEFAULT_GO_WALLET_TOOLBOX_URL
+    const env = Setup.getEnv('test')
+
+    try {
+      // Create wallet without any storage providers
+      setup = await Setup.createWallet({
+        env,
+        rootKeyHex: env.devKeys[env.identityKey]
+      })
+
+      // Create a StorageClient connected to the go-wallet-toolbox storage server
+      const storageClient = new StorageClient(setup.wallet, endpointUrl)
+      await storageClient.makeAvailable()
+      await setup.storage.addWalletStorageProvider(storageClient)
+
+      // Try to connect to verify the service is available
+      await setup.wallet.waitForAuthentication({})
+      walletServiceAvailable = true
+    } catch (error: any) {
+      walletServiceAvailable = false
+      const errorMessage = error?.message || String(error)
+
+      if (
+        errorMessage.includes('fetch failed') ||
+        errorMessage.includes('ECONNREFUSED') ||
+        errorMessage.includes('Network error')
+      ) {
+        console.error(
+          '\n' +
+            '='.repeat(80) +
+            '\n' +
+            '⚠️  GO WALLET TOOLBOX STORAGE SERVER NOT AVAILABLE\n' +
+            '='.repeat(80) +
+            '\n' +
+            `\nThe go-wallet-toolbox storage server is not running at ${endpointUrl}\n` +
+            '\nTo run these tests, you need to start the go-wallet-toolbox storage server.\n' +
+            '\nSetup steps:\n' +
+            '  1. Navigate to the go-wallet-toolbox directory:\n' +
+            '     cd ../go-wallet-toolbox\n' +
+            '  2. Generate a config file:\n' +
+            '     go run ./cmd/infra_config_gen -k\n' +
+            '  3. Start the storage server:\n' +
+            '     go run ./cmd/infra\n' +
+            '\nThe server should be available at http://localhost:8100\n' +
+            '\nFor more details, see the go-wallet-toolbox README.md\n' +
+            '\n' +
+            '='.repeat(80) +
+            '\n'
+        )
+
+        // Exit early to prevent running all tests
+        process.exit(1)
+      }
+
+      // Re-throw other errors
+      throw error
+    }
+  }, 10000)
+
+  afterAll(async () => {
+    // Cleanup: Abort any pending transactions we created
+    for (const reference of pendingAborts) {
+      try {
+        await setup.wallet.abortAction({ reference })
+      } catch (err) {
+        // Already aborted or completed - ignore
+      }
+    }
+    pendingAborts.length = 0
+  }, 10000)
+
+  // ============================================================================
+  //   Basics
+  // ============================================================================
+
+  describe('Basics', () => {
+    test('walletInfo - should retrieve wallet address and balance', async () => {
+      console.log('🔑 Testing wallet address and balance...')
+      const env = Setup.getEnv(setup.chain)
+
+      // Test address derivation
+      const address = PrivateKey.fromString(env.devKeys[env.identityKey])
+        .toPublicKey()
+        .toAddress(setup.chain === 'main' ? 'mainnet' : 'testnet')
+
+      console.log(`📍 Generated address: ${address.substring(0, 20)}...`)
+      expect(address).toBeDefined()
+      expect(typeof address).toBe('string')
+      expect(address.length).toBeGreaterThan(20)
+
+      // Test balance retrieval (may be 0 if no funds)
+      try {
+        const balance = await setup.wallet.balance()
+        console.log(`💰 Wallet balance: ${balance} sats`)
+        expect(typeof balance).toBe('number')
+        expect(balance).toBeGreaterThanOrEqual(0)
+      } catch (err: any) {
+        console.log('⚠️  Balance check failed (expected for local testing)')
+        // Balance might fail if services not configured, but that's expected
+      }
+      console.log('✅ Wallet info test completed')
+    }, 10000)
+
+    test('waitForAuthentication - should resolve immediately for base wallet', async () => {
+      console.log('🔐 Testing waitForAuthentication...')
+      const result = await setup.wallet.waitForAuthentication({})
+      console.log(`🔐 Authentication result: ${JSON.stringify(result)}`)
+      expect(result).toBeDefined()
+      expect(result.authenticated).toBeDefined()
+      // Base wallet resolves immediately
+      console.log('✅ waitForAuthentication test completed')
+    }, 10000)
+
+    test('isAuthenticated - should check if wallet is authenticated', async () => {
+      console.log('🔐 Testing isAuthenticated...')
+      const result = await setup.wallet.isAuthenticated({})
+      console.log(`🔐 Authentication check result: ${JSON.stringify(result)}`)
+      expect(result).toBeDefined()
+      expect(result.authenticated).toBeDefined()
+      expect(typeof result.authenticated).toBe('boolean')
+      console.log('✅ isAuthenticated test completed')
+    }, 10000)
+
+    test('getNetwork - should return the network information', async () => {
+      console.log('🌐 Testing getNetwork...')
+      const result = await setup.wallet.getNetwork({})
+      console.log(`🌐 Network info: ${JSON.stringify(result)}`)
+      expect(result).toBeDefined()
+      expect(result.network).toBeDefined()
+      expect(['main', 'test', 'testnet']).toContain(result.network)
+      console.log('✅ getNetwork test completed')
+    }, 10000)
+
+    test('getVersion - should return wallet version information', async () => {
+      console.log('📦 Testing getVersion...')
+      const result = await setup.wallet.getVersion({})
+      console.log(`📦 Version info: ${JSON.stringify(result)}`)
+      expect(result).toBeDefined()
+      expect(result.version).toBeDefined()
+      expect(typeof result.version).toBe('string')
+      console.log('✅ getVersion test completed')
+    }, 10000)
+  })
+
+  // ============================================================================
+  // Keys and Signatures
+  // ============================================================================
+
+  describe('Keys and Signatures', () => {
+    test('getPublicKey - should derive protocol-specific public key', async () => {
+      console.log('🔑 Testing public key derivation...')
+      const result = await setup.wallet.getPublicKey({
+        identityKey: true,
+        protocolID: [0, 'testprotocol'],
+        keyID: '1',
+        counterparty: 'self'
+      })
+
+      console.log(
+        `🔑 Derived public key: ${result.publicKey.substring(0, 20)}...`
+      )
+      expect(result).toBeDefined()
+      expect(result.publicKey).toBeDefined()
+      expect(typeof result.publicKey).toBe('string')
+      expect(result.publicKey.length).toBeGreaterThan(60) // Public key length
+      console.log('✅ Public key test completed')
+    }, 10000)
+
+    test('createSignature - should sign data with wallet keys', async () => {
+      console.log('✍️  Testing signature creation...')
+      const testMessage = 'Hello, BSV!'
+      const data = Array.from(Buffer.from(testMessage))
+
+      const result = await setup.wallet.createSignature({
+        data,
+        protocolID: [0, 'testprotocol'],
+        keyID: '1',
+        counterparty: 'self'
+      })
+      console.log(
+        `✍️  Created signature: ${Buffer.from(result.signature.slice(0, 10)).toString('hex')}...`
+      )
+      expect(result).toBeDefined()
+      expect(result.signature).toBeDefined()
+      console.log('✅ Signature creation test completed')
+    }, 10000)
+
+    test('verifySignature - should create and verify signature round-trip', async () => {
+      console.log('🔍 Testing signature verification...')
+      const testMessage = 'Test signature verification'
+      const data = Array.from(Buffer.from(testMessage))
+
+      // Create signature
+      const createResult = await setup.wallet.createSignature({
+        data,
+        protocolID: [0, 'testprotocol'],
+        keyID: '1',
+        counterparty: 'self'
+      })
+
+      // Verify signature
+      const verifyResult = await setup.wallet.verifySignature({
+        data,
+        signature: createResult.signature,
+        protocolID: [0, 'testprotocol'],
+        keyID: '1',
+        counterparty: 'self'
+      })
+
+      console.log(`🔍 Signature verification result: ${verifyResult.valid}`)
+      expect(verifyResult).toBeDefined()
+      expect(verifyResult.valid).toBe(true)
+      console.log('✅ Signature verification test completed')
+    }, 10000)
+
+    test('revealCounterpartyKeyLinkage - should reveal counterparty key linkage', async () => {
+      try {
+        const result = await setup.wallet.revealCounterpartyKeyLinkage({
+          counterparty: 'self',
+          verifier: '02' + 'a'.repeat(64), // demo verifier pubkey
+          privilegedReason: 'Demo'
+        })
+
+        expect(result).toBeDefined()
+        expect(result.prover).toBeDefined()
+        expect(result.counterparty).toBeDefined()
+      } catch (err: any) {
+        // This might fail in test environments, which is expected
+      }
+    }, 10000)
+
+    test('revealSpecificKeyLinkage - should reveal specific key linkage', async () => {
+      try {
+        const result = await setup.wallet.revealSpecificKeyLinkage({
+          counterparty: 'self',
+          verifier: '02' + 'a'.repeat(64), // demo verifier pubkey
+          protocolID: [0, 'testprotocol'],
+          keyID: '1',
+          privilegedReason: 'Demo'
+        })
+
+        expect(result).toBeDefined()
+        expect(result.prover).toBeDefined()
+        expect(result.counterparty).toBeDefined()
+        expect(result.protocolID).toBeDefined()
+        expect(result.keyID).toBeDefined()
+      } catch (err: any) {
+        // This might fail in test environments, which is expected
+      }
+    }, 10000)
+  })
+
+  // ============================================================================
+  // Crypto Operations
+  // ============================================================================
+
+  describe('Crypto Operations', () => {
+    test('createHmac - should generate HMAC for message', async () => {
+      console.log('🔐 Testing HMAC creation...')
+      const testMessage = 'Hello, HMAC!'
+      const data = Array.from(Buffer.from(testMessage))
+
+      const result = await setup.wallet.createHmac({
+        data,
+        protocolID: [0, 'testprotocol'],
+        keyID: '1',
+        counterparty: 'self'
+      })
+
+      console.log(
+        `🔐 Generated HMAC: ${Buffer.from(result.hmac.slice(0, 10)).toString('hex')}...`
+      )
+      expect(result).toBeDefined()
+      expect(result.hmac).toBeDefined()
+      console.log('✅ HMAC creation test completed')
+    }, 10000)
+
+    test('verifyHmac - should create and verify HMAC round-trip', async () => {
+      console.log('🔍 Testing HMAC verification...')
+      const testMessage = 'Test HMAC verification'
+      const data = Array.from(Buffer.from(testMessage))
+
+      // Create HMAC
+      const createResult = await setup.wallet.createHmac({
+        data,
+        protocolID: [0, 'testprotocol'],
+        keyID: '1',
+        counterparty: 'self'
+      })
+
+      // Verify HMAC
+      const verifyResult = await setup.wallet.verifyHmac({
+        data,
+        hmac: createResult.hmac,
+        protocolID: [0, 'testprotocol'],
+        keyID: '1',
+        counterparty: 'self'
+      })
+
+      console.log(`🔍 HMAC verification result: ${verifyResult.valid}`)
+      console.log('✅ HMAC verification test completed')
+      expect(verifyResult).toBeDefined()
+      expect(verifyResult.valid).toBe(true)
+      console.log('✅ HMAC verification test completed')
+    }, 10000)
+
+    test('encrypt/decrypt - should encrypt data and decrypt it back', async () => {
+      console.log('🔒 Testing encryption/decryption...')
+      const testMessage = 'Secret Message!'
+      const plaintext = Array.from(Buffer.from(testMessage))
+
+      // Encrypt
+      const encryptResult = await setup.wallet.encrypt({
+        plaintext,
+        protocolID: [0, 'encryption'],
+        keyID: '1',
+        counterparty: 'self'
+      })
+
+      console.log(
+        `🔒 Encrypted message: ${Buffer.from(encryptResult.ciphertext.slice(0, 10)).toString('hex')}...`
+      )
+      expect(encryptResult).toBeDefined()
+      expect(encryptResult.ciphertext).toBeDefined()
+
+      // Decrypt
+      const decryptResult = await setup.wallet.decrypt({
+        ciphertext: encryptResult.ciphertext,
+        protocolID: [0, 'encryption'],
+        keyID: '1',
+        counterparty: 'self'
+      })
+
+      expect(decryptResult).toBeDefined()
+      expect(decryptResult.plaintext).toBeDefined()
+      expect(Array.isArray(decryptResult.plaintext)).toBe(true)
+
+      // Verify decrypted message matches original
+      const decrypted = Buffer.from(decryptResult.plaintext).toString()
+      console.log(`🔓 Decrypted message: "${decrypted}"`)
+      expect(decrypted).toBe(testMessage)
+      console.log('✅ Encryption/decryption test completed')
+    }, 10000)
+  })
+
+  // ============================================================================
+  // Actions
+  // ============================================================================
+
+  describe('Actions', () => {
+    test('createAction - should create OP_RETURN transaction (noSend + abort)', async () => {
+      console.log('🚀 STARTING: createAction test (noSend + abort)')
+      // Check balance first - need at least 10 sats to safely run this test
+      const balance = await setup.wallet.balance()
+      if (balance < 10) {
+        console.log('⚠️  Skipping test - insufficient balance')
+        return
+      }
+
+      try {
+        const message = 'Hello, World! - Test Action'
+        const messageBytes = Buffer.from(message)
+        const hexData = messageBytes.toString('hex')
+        const length = messageBytes.length
+        const lockingScript = `006a${length.toString(16).padStart(2, '0')}${hexData}`
+
+        // Use noSend: true to create tx without broadcasting
+        console.log(`✍️  Creating action: "${message}"`)
+        const action = await setup.wallet.createAction({
+          description: `Store message: ${message}`,
+          outputs: [
+            {
+              lockingScript,
+              satoshis: 0,
+              outputDescription: 'Message output',
+              basket: 'opreturn',
+              tags: ['demo', 'opreturn']
+            }
+          ],
+          labels: ['demo:create_action'],
+          options: {
+            noSend: true // Don't broadcast - just create the transaction
+          }
+        })
+
+        console.log(
+          `✅ Action created with ${action.signableTransaction ? 'signableTransaction' : action.txid ? 'txid' : 'unknown'}`
+        )
+        if (action.signableTransaction?.reference) {
+          console.log(
+            `   Action reference: ${action.signableTransaction.reference}`
+          )
+        }
+        expect(action).toBeDefined()
+
+        // With noSend, wallet may return signableTransaction (needs signing) or txid (auto-signed)
+        if (action.signableTransaction?.reference) {
+          // Can abort - add to cleanup list and abort immediately
+          console.log(
+            `🗑️  Aborting action: ${action.signableTransaction.reference}`
+          )
+          pendingAborts.push(action.signableTransaction.reference)
+          const abortResult = await setup.wallet.abortAction({
+            reference: action.signableTransaction.reference
+          })
+          console.log(`✅ Action aborted: ${abortResult.aborted}`)
+          expect(abortResult.aborted).toBe(true)
+          // Remove from pending since we aborted it
+          pendingAborts.pop()
+        }
+        // else: auto-signed nosend tx - cleanup handles it
+      } catch (err: any) {
+        if (
+          err.message.includes('Insufficient funds') ||
+          err.message.includes('insufficient')
+        )
+          return
+        throw err
+      }
+    }, 15000)
+
+    test('createAction - verify action result structure', async () => {
+      // Check balance first
+      const balance = await setup.wallet.balance()
+      if (balance < 10) return
+
+      try {
+        const message = 'Structure Test'
+        const messageBytes = Buffer.from(message)
+        const hexData = messageBytes.toString('hex')
+        const length = messageBytes.length
+        const lockingScript = `006a${length.toString(16).padStart(2, '0')}${hexData}`
+
+        console.log(`✍️  Creating structure test action: "${message}"`)
+        // Create action with noSend to inspect the result structure
+        const action = await setup.wallet.createAction({
+          description: `Structure test: ${message}`,
+          outputs: [
+            {
+              lockingScript,
+              satoshis: 0,
+              outputDescription: 'Test output',
+              basket: 'opreturn',
+              tags: ['test']
+            }
+          ],
+          labels: ['test:structure'],
+          options: {
+            noSend: true
+          }
+        })
+
+        console.log(
+          `✅ Structure test action created with ${action.signableTransaction ? 'signableTransaction' : action.txid ? 'txid' : 'unknown'}`
+        )
+        expect(action).toBeDefined()
+
+        // Verify result structure - either signableTransaction or txid
+        if (action.signableTransaction) {
+          expect(action.signableTransaction.reference).toBeDefined()
+          expect(action.signableTransaction.tx).toBeDefined()
+          console.log(
+            `📝 Keeping action ${action.signableTransaction.reference} for database verification`
+          )
+          // Keep this action for the listActions test to find it
+          // Don't abort immediately - will be cleaned up in afterAll
+        } else if (action.txid) {
+          expect(typeof action.txid).toBe('string')
+          expect(action.txid.length).toBe(64)
+        } else {
+          throw new Error('Expected either signableTransaction or txid')
+        }
+      } catch (err: any) {
+        if (
+          err.message.includes('Insufficient funds') ||
+          err.message.includes('insufficient')
+        )
+          return
+        throw err
+      }
+    }, 15000)
+
+    test('listActions - should list recent wallet actions', async () => {
+      console.log(
+        '🔍 Checking for actions in database before action creation tests...'
+      )
+      const actions = await setup.wallet.listActions({
+        labels: [],
+        limit: 10,
+        includeLabels: true
+      })
+
+      console.log(`📋 Listed ${actions.actions.length} actions from database`)
+      if (actions.actions.length > 0) {
+        console.log(`   First action: ${actions.actions[0].description}`)
+      }
+
+      expect(actions).toBeDefined()
+      expect(actions.actions).toBeDefined()
+      expect(Array.isArray(actions.actions)).toBe(true)
+      expect(actions.actions.length).toBeGreaterThanOrEqual(0)
+    }, 10000)
+
+    test('abortAction - should abort an unsigned action if available', async () => {
+      console.log('🗑️  Testing action abortion...')
+      // Check if there are any unsigned actions we can abort
+      const actions = await setup.wallet.listActions({ labels: [], limit: 20 })
+      const unsignedAction = actions.actions.find(
+        a => a.status === 'unsigned' || a.status === 'nosend'
+      )
+
+      console.log(
+        `📋 Found ${actions.actions.length} total actions, ${unsignedAction ? 1 : 0} unsigned`
+      )
+      // listActions doesn't return references, so we can only abort
+      // actions we created in the same session with signableTransaction
+      expect(unsignedAction === undefined || unsignedAction.status).toBeTruthy()
+      console.log('✅ Action abortion test completed')
+    }, 10000)
+  })
+
+  // ============================================================================
+  // Outputs
+  // ============================================================================
+
+  describe('Outputs', () => {
+    test('listOutputs - should list wallet outputs', async () => {
+      const outputs = await setup.wallet.listOutputs({
+        basket: 'default',
+        limit: 10,
+        offset: 0
+      })
+
+      console.log(
+        `💰 Listed ${outputs.outputs.length} outputs from database (total: ${outputs.totalOutputs})`
+      )
+      if (outputs.outputs.length > 0) {
+        console.log(`   First output: ${outputs.outputs[0].satoshis} sats`)
+      }
+
+      expect(outputs).toBeDefined()
+      expect(outputs.outputs).toBeDefined()
+      expect(Array.isArray(outputs.outputs)).toBe(true)
+      expect(typeof outputs.totalOutputs).toBe('number')
+      expect(outputs.totalOutputs).toBeGreaterThanOrEqual(0)
+    }, 10000)
+
+    test('relinquishOutput - should relinquish an output from wallet tracking', async () => {
+      console.log('🗑️  Testing output relinquishment...')
+      // Use a dummy outpoint since we likely don't have real outputs to relinquish
+      const dummyOutpoint =
+        '0000000000000000000000000000000000000000000000000000000000000000:0'
+
+      try {
+        const result = await setup.wallet.relinquishOutput({
+          basket: 'default',
+          output: dummyOutpoint
+        })
+
+        console.log('✅ Output relinquished successfully')
+        expect(result).toBeDefined()
+        expect(result.relinquished).toBeDefined()
+      } catch (err: any) {
+        console.log(
+          '⚠️  Output relinquishment failed (expected with dummy outpoint)'
+        )
+        // Expected to fail with dummy outpoint
+        expect(err).toBeDefined()
+      }
+      console.log('✅ Output relinquishment test completed')
+    }, 10000)
+  })
+
+  // ============================================================================
+  // Certificates
+  // ============================================================================
+
+  describe('Certificates', () => {
+    test('acquireCertificate - should attempt to acquire a certificate', async () => {
+      console.log('📜 Testing certificate acquisition...')
+      try {
+        const result = await setup.wallet.acquireCertificate({
+          type: Buffer.from('test-certificate').toString('base64'),
+          certifier: setup.identityKey,
+          acquisitionProtocol: 'issuance',
+          certifierUrl: 'http://localhost:8100',
+          fields: {
+            name: 'Test User',
+            email: 'test@example.com'
+          },
+          privilegedReason: 'Demo acquisition'
+        })
+        console.log('📜 Certificate acquired successfully')
+        expect(result).toBeDefined()
+      } catch (err: any) {
+        console.log(
+          '⚠️  Certificate acquisition failed (expected in local test environment)'
+        )
+        // Expected to fail in test environment
+        expect(err).toBeDefined()
+      }
+      console.log('✅ Certificate acquisition test completed')
+    }, 10000)
+
+    test('listCertificates - should list wallet certificates', async () => {
+      const certs = await setup.wallet.listCertificates({
+        certifiers: [],
+        types: [],
+        limit: 10,
+        offset: 0
+      })
+
+      console.log(
+        `📜 Listed ${certs.certificates.length} certificates from database`
+      )
+      if (certs.certificates.length > 0) {
+        console.log(
+          `   Certificate types: ${certs.certificates.map(c => c.type).join(', ')}`
+        )
+      }
+
+      expect(certs).toBeDefined()
+      expect(certs.certificates).toBeDefined()
+      expect(Array.isArray(certs.certificates)).toBe(true)
+      expect(certs.certificates.length).toBeGreaterThanOrEqual(0)
+      if (certs.certificates.length > 0) {
+        const testCert = certs.certificates.find(
+          c => c.type === 'test-certificate'
+        )
+        if (testCert) {
+          expect(testCert.subject).toBeDefined()
+        }
+      }
+    }, 10000)
+
+    test('relinquishCertificate - should relinquish a certificate', async () => {
+      console.log('🗑️  Testing certificate relinquishment...')
+      // First check if we have any certificates to relinquish
+      const certs = await setup.wallet.listCertificates({
+        certifiers: [],
+        types: [],
+        limit: 10,
+        offset: 0
+      })
+
+      console.log(
+        `📜 Found ${certs.certificates.length} certificates to potentially relinquish`
+      )
+      if (certs.certificates.length === 0) {
+        console.log('⚠️  No certificates to relinquish, skipping test')
+        return
+      }
+
+      // Try to relinquish the first certificate
+      const cert = certs.certificates[0]
+      console.log(`🗑️  Attempting to relinquish certificate: ${cert.type}`)
+
+      try {
+        await setup.wallet.relinquishCertificate({
+          type: cert.type,
+          certifier: cert.certifier || 'self',
+          serialNumber: cert.serialNumber || ''
+        })
+        console.log('✅ Certificate relinquished successfully')
+      } catch (err: any) {
+        console.log(
+          '⚠️  Certificate relinquishment failed (expected in test environment)'
+        )
+        // Expected to fail in test environment
+        expect(err).toBeDefined()
+      }
+      console.log('✅ Certificate relinquishment test completed')
+    }, 10000)
+  })
+
+  // ============================================================================
+  // Identity Discovery
+  // ============================================================================
+
+  describe('Identity Discovery', () => {
+    test('discoverByIdentityKey - should discover certificates by identity key', async () => {
+      console.log('🔍 Testing identity discovery by identity key...')
+      try {
+        const result = await setup.wallet.discoverByIdentityKey({
+          identityKey: setup.identityKey,
+          limit: 10,
+          offset: 0,
+          seekPermission: true
+        })
+
+        console.log(
+          `🔍 Found ${result.certificates.length} certificates by identity key`
+        )
+        expect(result).toBeDefined()
+        expect(result.certificates).toBeDefined()
+        expect(Array.isArray(result.certificates)).toBe(true)
+        console.log('✅ Identity discovery by identity key completed')
+      } catch (err: any) {
+        console.log(
+          '⚠️  Identity discovery by identity key failed (expected in local test environment)'
+        )
+        // Expected to fail in test environment
+        expect(err).toBeDefined()
+      }
+    }, 10000)
+
+    test('discoverByAttributes - should discover certificates by attributes', async () => {
+      console.log('🔍 Testing identity discovery by attributes...')
+      try {
+        const result = await setup.wallet.discoverByAttributes({
+          attributes: { verified: 'true' },
+          limit: 10,
+          offset: 0
+        })
+
+        console.log(
+          `🔍 Found ${result.certificates.length} certificates by attributes`
+        )
+        expect(result).toBeDefined()
+        expect(result.certificates).toBeDefined()
+        expect(Array.isArray(result.certificates)).toBe(true)
+        console.log('✅ Identity discovery by attributes completed')
+      } catch (err: any) {
+        console.log(
+          '⚠️  Identity discovery by attributes failed (expected in local test environment)'
+        )
+        // Expected to fail in test environment
+        expect(err).toBeDefined()
+      }
+    }, 10000)
+  })
+
+  // ============================================================================
+  // Transactions
+  // ============================================================================
+
+  describe('Transactions', () => {
+    test('internalizeAction - should internalize an external transaction', async () => {
+      console.log('📥 Testing transaction internalization...')
+      // This is a complex operation that requires an actual external transaction
+      // For testing purposes, we'll try with minimal parameters and expect graceful failure
+      try {
+        const dummyTxHex =
+          '01000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0100ffffffff01000000000000000000000000'
+        const result = await setup.wallet.internalizeAction({
+          tx: Array.from(Buffer.from(dummyTxHex, 'hex')),
+          outputs: [
+            {
+              outputIndex: 0,
+              protocol: 'basket insertion',
+              insertionRemittance: {
+                basket: 'default'
+              }
+            }
+          ],
+          description: 'Test internalization of external transaction'
+        })
+
+        console.log('✅ Transaction internalized successfully')
+        expect(result).toBeDefined()
+      } catch (err: any) {
+        console.log(
+          '⚠️  Transaction internalization failed (expected with dummy data)'
+        )
+        // Expected to fail with dummy data
+        expect(err).toBeDefined()
+      }
+      console.log('✅ Transaction internalization test completed')
+    }, 10000)
+  })
+
+  // ============================================================================
+  // Blockchain Info
+  // ============================================================================
+
+  describe.skip('Blockchain Info', () => {
+    test('getHeight - should fetch current block height', async () => {
+      // Skipped for Go storage server tests - requires external blockchain API
+    }, 10000)
+
+    test('getHeaderForHeight - should fetch header for specific height', async () => {
+      // Skipped for Go storage server tests - requires external blockchain API
+    }, 10000)
+  })
+})
diff --git a/src/brc100.local.test.ts b/src/brc100.local.test.ts
new file mode 100644
index 0000000..dc55b88
--- /dev/null
+++ b/src/brc100.local.test.ts
@@ -0,0 +1,814 @@
+import { PrivateKey } from '@bsv/sdk'
+import { Setup, SetupWallet, StorageKnex } from '@bsv/wallet-toolbox'
+import { Knex, knex as makeKnex } from 'knex'
+
+// Helper to create SQLite Knex connection
+function createSQLiteKnex(filename: string): Knex {
+  const config: Knex.Config = {
+    client: 'sqlite3',
+    connection: { filename },
+    useNullAsDefault: true
+  }
+  const knex = makeKnex(config)
+  return knex
+}
+
+/**
+ * Track nosend transaction references for cleanup.
+ * Tests that create nosend transactions should add their references here.
+ */
+const pendingAborts: string[] = []
+
+/**
+ * Track knex connections for cleanup.
+ */
+let knexConnections: any[] = []
+
+describe('BRC-100 Wallet Operations', () => {
+  let setup: SetupWallet
+  let walletServiceAvailable = false
+
+  beforeAll(async () => {
+    const env = Setup.getEnv('test')
+
+    try {
+      // Create wallet without any storage providers
+      setup = await Setup.createWallet({
+        env,
+        rootKeyHex: env.devKeys[env.identityKey]
+      })
+
+      // Create local SQLite storage
+      const dbFilePath = `wallet_test_brc100.local.sqlite`
+      console.log(`🔄 Creating local SQLite database: ${dbFilePath}`)
+      const knex = createSQLiteKnex(dbFilePath)
+      knexConnections.push(knex) // Track for cleanup
+      const localStorage = new StorageKnex({
+        knex,
+        chain: env.chain,
+        feeModel: { model: 'sat/kb', value: 1 },
+        commissionSatoshis: 0
+      })
+      console.log('🔄 Running database migrations...')
+      await localStorage.migrate(dbFilePath, dbFilePath)
+      console.log('✅ Database migrations completed')
+      await setup.storage.addWalletStorageProvider(localStorage)
+      console.log('✅ Local SQLite storage provider added to wallet')
+
+      // Local storage doesn't require authentication verification
+      walletServiceAvailable = true
+    } catch (error: any) {
+      walletServiceAvailable = false
+      const errorMessage = error?.message || String(error)
+
+      console.error(
+        '\n' +
+          '='.repeat(80) +
+          '\n' +
+          '⚠️  LOCAL STORAGE SETUP FAILED\n' +
+          '='.repeat(80) +
+          '\n' +
+          `\nFailed to set up local SQLite storage: ${errorMessage}\n` +
+          '\n' +
+          '='.repeat(80) +
+          '\n'
+      )
+
+      // Exit early to prevent running all tests
+      process.exit(1)
+    }
+  }, 5000) // Reduced timeout
+
+  afterAll(async () => {
+    // Cleanup: Abort any pending transactions we created
+    for (const reference of pendingAborts) {
+      try {
+        await setup.wallet.abortAction({ reference })
+      } catch (err) {
+        // Already aborted or completed - ignore
+      }
+    }
+    pendingAborts.length = 0
+
+    // Properly destroy the wallet and storage to close any open connections
+    try {
+      await setup.wallet.destroy()
+    } catch (err) {
+      // Ignore destroy errors
+    }
+
+    console.log('🧹 Cleaning up database connections...')
+    // Clean up knex connections
+    for (const knex of knexConnections) {
+      try {
+        await knex.destroy()
+        console.log('✅ Database connection closed')
+      } catch (err) {
+        // Ignore cleanup errors
+      }
+    }
+    knexConnections.length = 0
+  }, 5000) // Reduced timeout
+
+  // ============================================================================
+  //   Basics
+  // ============================================================================
+
+  describe('Basics', () => {
+    test('walletInfo - should retrieve wallet address and balance', async () => {
+      console.log('🔑 Testing wallet address and balance...')
+      const env = Setup.getEnv(setup.chain)
+
+      // Test address derivation
+      const address = PrivateKey.fromString(env.devKeys[env.identityKey])
+        .toPublicKey()
+        .toAddress(setup.chain === 'main' ? 'mainnet' : 'testnet')
+
+      console.log(`📍 Generated address: ${address.substring(0, 20)}...`)
+      expect(address).toBeDefined()
+      expect(typeof address).toBe('string')
+      expect(address.length).toBeGreaterThan(20)
+
+      // Test balance retrieval (may be 0 if no funds)
+      try {
+        const balance = await setup.wallet.balance()
+        console.log(`💰 Wallet balance: ${balance} sats`)
+        expect(typeof balance).toBe('number')
+        expect(balance).toBeGreaterThanOrEqual(0)
+      } catch (err: any) {
+        console.log('⚠️  Balance check failed (expected for local testing)')
+        // Balance might fail if services not configured, but that's expected
+      }
+      console.log('✅ Wallet info test completed')
+    }, 10000)
+
+    // test('waitForAuthentication - should resolve immediately for base wallet', async () => {
+    //   const result = await setup.wallet.waitForAuthentication({})
+    //   expect(result).toBeDefined()
+    //   expect(result.authenticated).toBeDefined()
+    //   // Base wallet resolves immediately
+    // }, 10000)
+
+    // test('isAuthenticated - should check if wallet is authenticated', async () => {
+    //   const result = await setup.wallet.isAuthenticated({})
+    //   expect(result).toBeDefined()
+    //   expect(result.authenticated).toBeDefined()
+    //   expect(typeof result.authenticated).toBe('boolean')
+    // }, 10000)
+
+    // test('getNetwork - should return the network information', async () => {
+    //   const result = await setup.wallet.getNetwork({})
+    //   expect(result).toBeDefined()
+    //   expect(result.network).toBeDefined()
+    //   expect(['main', 'test', 'testnet']).toContain(result.network)
+    // }, 10000)
+
+    // test('getVersion - should return wallet version information', async () => {
+    //   const result = await setup.wallet.getVersion({})
+    //   expect(result).toBeDefined()
+    //   expect(result.version).toBeDefined()
+    //   expect(typeof result.version).toBe('string')
+    // }, 10000)
+  })
+
+  // ============================================================================
+  // Keys and Signatures
+  // ============================================================================
+
+  describe('Keys and Signatures', () => {
+    test('getPublicKey - should derive protocol-specific public key', async () => {
+      console.log('🔑 Testing public key derivation...')
+      const result = await setup.wallet.getPublicKey({
+        identityKey: true,
+        protocolID: [0, 'testprotocol'],
+        keyID: '1',
+        counterparty: 'self'
+      })
+
+      console.log(
+        `🔑 Derived public key: ${result.publicKey.substring(0, 20)}...`
+      )
+      expect(result).toBeDefined()
+      expect(result.publicKey).toBeDefined()
+      expect(typeof result.publicKey).toBe('string')
+      expect(result.publicKey.length).toBeGreaterThan(60) // Public key length
+      console.log('✅ Public key test completed')
+    }, 10000)
+
+    test('createSignature - should sign data with wallet keys', async () => {
+      console.log('✍️  Testing signature creation...')
+      const testMessage = 'Hello, BSV!'
+      const data = Array.from(Buffer.from(testMessage))
+
+      const result = await setup.wallet.createSignature({
+        data,
+        protocolID: [0, 'testprotocol'],
+        keyID: '1',
+        counterparty: 'self'
+      })
+      console.log(
+        `✍️  Created signature: ${Buffer.from(result.signature.slice(0, 10)).toString('hex')}...`
+      )
+      expect(result).toBeDefined()
+      expect(result.signature).toBeDefined()
+      console.log('✅ Signature creation test completed')
+    }, 10000)
+
+    test('verifySignature - should create and verify signature round-trip', async () => {
+      console.log('🔍 Testing signature verification...')
+      const testMessage = 'Test signature verification'
+      const data = Array.from(Buffer.from(testMessage))
+
+      // Create signature
+      const createResult = await setup.wallet.createSignature({
+        data,
+        protocolID: [0, 'testprotocol'],
+        keyID: '1',
+        counterparty: 'self'
+      })
+
+      // Verify signature
+      const verifyResult = await setup.wallet.verifySignature({
+        data,
+        signature: createResult.signature,
+        protocolID: [0, 'testprotocol'],
+        keyID: '1',
+        counterparty: 'self'
+      })
+
+      console.log(`🔍 Signature verification result: ${verifyResult.valid}`)
+      expect(verifyResult).toBeDefined()
+      expect(verifyResult.valid).toBe(true)
+      console.log('✅ Signature verification test completed')
+    }, 10000)
+
+    test('revealCounterpartyKeyLinkage - should reveal counterparty key linkage', async () => {
+      try {
+        const result = await setup.wallet.revealCounterpartyKeyLinkage({
+          counterparty: 'self',
+          verifier: '02' + 'a'.repeat(64), // demo verifier pubkey
+          privilegedReason: 'Demo'
+        })
+
+        expect(result).toBeDefined()
+        expect(result.prover).toBeDefined()
+        expect(result.counterparty).toBeDefined()
+      } catch (err: any) {
+        // This might fail in test environments, which is expected
+      }
+    }, 10000)
+
+    test('revealSpecificKeyLinkage - should reveal specific key linkage', async () => {
+      try {
+        const result = await setup.wallet.revealSpecificKeyLinkage({
+          counterparty: 'self',
+          verifier: '02' + 'a'.repeat(64), // demo verifier pubkey
+          protocolID: [0, 'testprotocol'],
+          keyID: '1',
+          privilegedReason: 'Demo'
+        })
+
+        expect(result).toBeDefined()
+        expect(result.prover).toBeDefined()
+        expect(result.counterparty).toBeDefined()
+        expect(result.protocolID).toBeDefined()
+        expect(result.keyID).toBeDefined()
+      } catch (err: any) {
+        // This might fail in test environments, which is expected
+      }
+    }, 10000)
+  })
+
+  // ============================================================================
+  // Crypto Operations
+  // ============================================================================
+
+  describe('Crypto Operations', () => {
+    test('createHmac - should generate HMAC for message', async () => {
+      console.log('🔐 Testing HMAC creation...')
+      const testMessage = 'Hello, HMAC!'
+      const data = Array.from(Buffer.from(testMessage))
+
+      const result = await setup.wallet.createHmac({
+        data,
+        protocolID: [0, 'testprotocol'],
+        keyID: '1',
+        counterparty: 'self'
+      })
+
+      console.log(
+        `🔐 Generated HMAC: ${Buffer.from(result.hmac.slice(0, 10)).toString('hex')}...`
+      )
+      expect(result).toBeDefined()
+      expect(result.hmac).toBeDefined()
+      console.log('✅ HMAC creation test completed')
+    }, 10000)
+
+    test('verifyHmac - should create and verify HMAC round-trip', async () => {
+      console.log('🔍 Testing HMAC verification...')
+      const testMessage = 'Test HMAC verification'
+      const data = Array.from(Buffer.from(testMessage))
+
+      // Create HMAC
+      const createResult = await setup.wallet.createHmac({
+        data,
+        protocolID: [0, 'testprotocol'],
+        keyID: '1',
+        counterparty: 'self'
+      })
+
+      // Verify HMAC
+      const verifyResult = await setup.wallet.verifyHmac({
+        data,
+        hmac: createResult.hmac,
+        protocolID: [0, 'testprotocol'],
+        keyID: '1',
+        counterparty: 'self'
+      })
+
+      console.log(`🔍 HMAC verification result: ${verifyResult.valid}`)
+      console.log('✅ HMAC verification test completed')
+      expect(verifyResult).toBeDefined()
+      expect(verifyResult.valid).toBe(true)
+      console.log('✅ HMAC verification test completed')
+    }, 10000)
+
+    test('encrypt/decrypt - should encrypt data and decrypt it back', async () => {
+      console.log('🔒 Testing encryption/decryption...')
+      const testMessage = 'Secret Message!'
+      const plaintext = Array.from(Buffer.from(testMessage))
+
+      // Encrypt
+      const encryptResult = await setup.wallet.encrypt({
+        plaintext,
+        protocolID: [0, 'encryption'],
+        keyID: '1',
+        counterparty: 'self'
+      })
+
+      console.log(
+        `🔒 Encrypted message: ${Buffer.from(encryptResult.ciphertext.slice(0, 10)).toString('hex')}...`
+      )
+      expect(encryptResult).toBeDefined()
+      expect(encryptResult.ciphertext).toBeDefined()
+
+      // Decrypt
+      const decryptResult = await setup.wallet.decrypt({
+        ciphertext: encryptResult.ciphertext,
+        protocolID: [0, 'encryption'],
+        keyID: '1',
+        counterparty: 'self'
+      })
+
+      expect(decryptResult).toBeDefined()
+      expect(decryptResult.plaintext).toBeDefined()
+      expect(Array.isArray(decryptResult.plaintext)).toBe(true)
+
+      // Verify decrypted message matches original
+      const decrypted = Buffer.from(decryptResult.plaintext).toString()
+      console.log(`🔓 Decrypted message: "${decrypted}"`)
+      expect(decrypted).toBe(testMessage)
+      console.log('✅ Encryption/decryption test completed')
+    }, 10000)
+  })
+
+  // ============================================================================
+  //   Actions
+  // ============================================================================
+
+  describe('Actions', () => {
+    test('createAction - should create OP_RETURN transaction (noSend + abort)', async () => {
+      console.log('🚀 STARTING: createAction test (noSend + abort)')
+      // Check balance first - need at least 10 sats to safely run this test
+      const balance = await setup.wallet.balance()
+      if (balance < 10) {
+        console.log('⚠️  Skipping test - insufficient balance')
+        return
+      }
+
+      try {
+        const message = 'Hello, World! - Test Action'
+        const messageBytes = Buffer.from(message)
+        const hexData = messageBytes.toString('hex')
+        const length = messageBytes.length
+        const lockingScript = `006a${length.toString(16).padStart(2, '0')}${hexData}`
+
+        // Use noSend: true to create tx without broadcasting
+        console.log(`✍️  Creating action: "${message}"`)
+        const action = await setup.wallet.createAction({
+          description: `Store message: ${message}`,
+          outputs: [
+            {
+              lockingScript,
+              satoshis: 0,
+              outputDescription: 'Message output',
+              basket: 'opreturn',
+              tags: ['demo', 'opreturn']
+            }
+          ],
+          labels: ['demo:create_action'],
+          options: {
+            noSend: true // Don't broadcast - just create the transaction
+          }
+        })
+
+        console.log(
+          `✅ Action created with ${action.signableTransaction ? 'signableTransaction' : action.txid ? 'txid' : 'unknown'}`
+        )
+        if (action.signableTransaction?.reference) {
+          console.log(
+            `   Action reference: ${action.signableTransaction.reference}`
+          )
+        }
+        expect(action).toBeDefined()
+
+        // With noSend, wallet may return signableTransaction (needs signing) or txid (auto-signed)
+        if (action.signableTransaction?.reference) {
+          // Can abort - add to cleanup list and abort immediately
+          console.log(
+            `🗑️  Aborting action: ${action.signableTransaction.reference}`
+          )
+          pendingAborts.push(action.signableTransaction.reference)
+          const abortResult = await setup.wallet.abortAction({
+            reference: action.signableTransaction.reference
+          })
+          console.log(`✅ Action aborted: ${abortResult.aborted}`)
+          expect(abortResult.aborted).toBe(true)
+          // Remove from pending since we aborted it
+          pendingAborts.pop()
+        }
+        // else: auto-signed nosend tx - cleanup handles it
+      } catch (err: any) {
+        if (
+          err.message.includes('Insufficient funds') ||
+          err.message.includes('insufficient')
+        )
+          return
+        throw err
+      }
+    }, 15000)
+
+    test('createAction - verify action result structure', async () => {
+      // Check balance first
+      const balance = await setup.wallet.balance()
+      if (balance < 10) return
+
+      try {
+        const message = 'Structure Test'
+        const messageBytes = Buffer.from(message)
+        const hexData = messageBytes.toString('hex')
+        const length = messageBytes.length
+        const lockingScript = `006a${length.toString(16).padStart(2, '0')}${hexData}`
+
+        console.log(`✍️  Creating structure test action: "${message}"`)
+        // Create action with noSend to inspect the result structure
+        const action = await setup.wallet.createAction({
+          description: `Structure test: ${message}`,
+          outputs: [
+            {
+              lockingScript,
+              satoshis: 0,
+              outputDescription: 'Test output',
+              basket: 'opreturn',
+              tags: ['test']
+            }
+          ],
+          labels: ['test:structure'],
+          options: {
+            noSend: true
+          }
+        })
+
+        console.log(
+          `✅ Structure test action created with ${action.signableTransaction ? 'signableTransaction' : action.txid ? 'txid' : 'unknown'}`
+        )
+        expect(action).toBeDefined()
+
+        // Verify result structure - either signableTransaction or txid
+        if (action.signableTransaction) {
+          expect(action.signableTransaction.reference).toBeDefined()
+          expect(action.signableTransaction.tx).toBeDefined()
+          console.log(
+            `📝 Keeping action ${action.signableTransaction.reference} for database verification`
+          )
+          // Keep this action for the listActions test to find it
+          // Don't abort immediately - will be cleaned up in afterAll
+        } else if (action.txid) {
+          expect(typeof action.txid).toBe('string')
+          expect(action.txid.length).toBe(64)
+        } else {
+          throw new Error('Expected either signableTransaction or txid')
+        }
+      } catch (err: any) {
+        if (
+          err.message.includes('Insufficient funds') ||
+          err.message.includes('insufficient')
+        )
+          return
+        throw err
+      }
+    }, 15000)
+
+    test('listActions - should list recent wallet actions', async () => {
+      console.log(
+        '🔍 Checking for actions in database before action creation tests...'
+      )
+      const actions = await setup.wallet.listActions({
+        labels: [],
+        limit: 10,
+        includeLabels: true
+      })
+
+      console.log(`📋 Listed ${actions.actions.length} actions from database`)
+      if (actions.actions.length > 0) {
+        console.log(`   First action: ${actions.actions[0].description}`)
+      }
+
+      expect(actions).toBeDefined()
+      expect(actions.actions).toBeDefined()
+      expect(Array.isArray(actions.actions)).toBe(true)
+      expect(actions.actions.length).toBeGreaterThanOrEqual(0)
+    }, 10000)
+
+    test('abortAction - should abort an unsigned action if available', async () => {
+      console.log('🗑️  Testing action abortion...')
+      // Check if there are any unsigned actions we can abort
+      const actions = await setup.wallet.listActions({ labels: [], limit: 20 })
+      const unsignedAction = actions.actions.find(
+        a => a.status === 'unsigned' || a.status === 'nosend'
+      )
+
+      console.log(
+        `📋 Found ${actions.actions.length} total actions, ${unsignedAction ? 1 : 0} unsigned`
+      )
+      // listActions doesn't return references, so we can only abort
+      // actions we created in the same session with signableTransaction
+      expect(unsignedAction === undefined || unsignedAction.status).toBeTruthy()
+      console.log('✅ Action abortion test completed')
+    }, 10000)
+  })
+
+  // ============================================================================
+  //   Outputs
+  // ============================================================================
+
+  describe('Outputs', () => {
+    test('listOutputs - should list wallet outputs', async () => {
+      const outputs = await setup.wallet.listOutputs({
+        basket: 'default',
+        limit: 10,
+        offset: 0
+      })
+
+      console.log(
+        `💰 Listed ${outputs.outputs.length} outputs from database (total: ${outputs.totalOutputs})`
+      )
+      if (outputs.outputs.length > 0) {
+        console.log(`   First output: ${outputs.outputs[0].satoshis} sats`)
+      }
+
+      expect(outputs).toBeDefined()
+      expect(outputs.outputs).toBeDefined()
+      expect(Array.isArray(outputs.outputs)).toBe(true)
+      expect(typeof outputs.totalOutputs).toBe('number')
+      expect(outputs.totalOutputs).toBeGreaterThanOrEqual(0)
+    }, 10000)
+
+    test('relinquishOutput - should relinquish an output from wallet tracking', async () => {
+      console.log('🗑️  Testing output relinquishment...')
+      // Use a dummy outpoint since we likely don't have real outputs to relinquish
+      const dummyOutpoint =
+        '0000000000000000000000000000000000000000000000000000000000000000:0'
+
+      try {
+        const result = await setup.wallet.relinquishOutput({
+          basket: 'default',
+          output: dummyOutpoint
+        })
+
+        console.log('✅ Output relinquished successfully')
+        expect(result).toBeDefined()
+        expect(result.relinquished).toBeDefined()
+      } catch (err: any) {
+        console.log(
+          '⚠️  Output relinquishment failed (expected with dummy outpoint)'
+        )
+        // Expected to fail with dummy outpoint
+        expect(err).toBeDefined()
+      }
+      console.log('✅ Output relinquishment test completed')
+    }, 10000)
+  })
+
+  // ============================================================================
+  //   Certificates
+  // ============================================================================
+
+  describe('Certificates', () => {
+    test('acquireCertificate - should attempt to acquire a certificate', async () => {
+      console.log('📜 Testing certificate acquisition...')
+      try {
+        const result = await setup.wallet.acquireCertificate({
+          type: Buffer.from('test-certificate').toString('base64'),
+          certifier: setup.identityKey,
+          acquisitionProtocol: 'issuance',
+          certifierUrl: 'http://localhost:8080',
+          fields: {
+            name: 'Test User',
+            email: 'test@example.com'
+          },
+          privilegedReason: 'Demo acquisition'
+        })
+        console.log('📜 Certificate acquired successfully')
+        expect(result).toBeDefined()
+      } catch (err: any) {
+        console.log(
+          '⚠️  Certificate acquisition failed (expected in local test environment)'
+        )
+        // Expected to fail in test environment
+        expect(err).toBeDefined()
+      }
+      console.log('✅ Certificate acquisition test completed')
+    }, 10000)
+
+    test('listCertificates - should list wallet certificates', async () => {
+      const certs = await setup.wallet.listCertificates({
+        certifiers: [],
+        types: [],
+        limit: 10,
+        offset: 0
+      })
+
+      console.log(
+        `📜 Listed ${certs.certificates.length} certificates from database`
+      )
+      if (certs.certificates.length > 0) {
+        console.log(
+          `   Certificate types: ${certs.certificates.map(c => c.type).join(', ')}`
+        )
+      }
+
+      expect(certs).toBeDefined()
+      expect(certs.certificates).toBeDefined()
+      expect(Array.isArray(certs.certificates)).toBe(true)
+      expect(certs.certificates.length).toBeGreaterThanOrEqual(0)
+      if (certs.certificates.length > 0) {
+        const testCert = certs.certificates.find(
+          c => c.type === 'test-certificate'
+        )
+        if (testCert) {
+          expect(testCert.subject).toBeDefined()
+        }
+      }
+    }, 10000)
+
+    test('relinquishCertificate - should relinquish a certificate', async () => {
+      console.log('🗑️  Testing certificate relinquishment...')
+      // First check if we have any certificates to relinquish
+      const certs = await setup.wallet.listCertificates({
+        certifiers: [],
+        types: [],
+        limit: 10,
+        offset: 0
+      })
+
+      console.log(
+        `📜 Found ${certs.certificates.length} certificates to potentially relinquish`
+      )
+      if (certs.certificates.length === 0) {
+        console.log('⚠️  No certificates to relinquish, skipping test')
+        return
+      }
+
+      // Try to relinquish the first certificate
+      const cert = certs.certificates[0]
+      console.log(`🗑️  Attempting to relinquish certificate: ${cert.type}`)
+
+      try {
+        await setup.wallet.relinquishCertificate({
+          type: cert.type,
+          certifier: cert.certifier || 'self',
+          serialNumber: cert.serialNumber || ''
+        })
+        console.log('✅ Certificate relinquished successfully')
+      } catch (err: any) {
+        console.log(
+          '⚠️  Certificate relinquishment failed (expected in test environment)'
+        )
+        // Expected to fail in test environment
+        expect(err).toBeDefined()
+      }
+      console.log('✅ Certificate relinquishment test completed')
+    }, 10000)
+  })
+
+  // ============================================================================
+  //   Identity Discovery
+  // ============================================================================
+
+  describe('Identity Discovery', () => {
+    test('discoverByIdentityKey - should discover certificates by identity key', async () => {
+      console.log('🔍 Testing identity discovery by identity key...')
+      try {
+        const result = await setup.wallet.discoverByIdentityKey({
+          identityKey: setup.identityKey,
+          limit: 10,
+          offset: 0,
+          seekPermission: true
+        })
+
+        console.log(
+          `🔍 Found ${result.certificates.length} certificates by identity key`
+        )
+        expect(result).toBeDefined()
+        expect(result.certificates).toBeDefined()
+        expect(Array.isArray(result.certificates)).toBe(true)
+        console.log('✅ Identity discovery by identity key completed')
+      } catch (err: any) {
+        console.log(
+          '⚠️  Identity discovery by identity key failed (expected in local test environment)'
+        )
+        // Expected to fail in test environment
+        expect(err).toBeDefined()
+      }
+    }, 10000)
+
+    test('discoverByAttributes - should discover certificates by attributes', async () => {
+      console.log('🔍 Testing identity discovery by attributes...')
+      try {
+        const result = await setup.wallet.discoverByAttributes({
+          attributes: { verified: 'true' },
+          limit: 10,
+          offset: 0
+        })
+
+        console.log(
+          `🔍 Found ${result.certificates.length} certificates by attributes`
+        )
+        expect(result).toBeDefined()
+        expect(result.certificates).toBeDefined()
+        expect(Array.isArray(result.certificates)).toBe(true)
+        console.log('✅ Identity discovery by attributes completed')
+      } catch (err: any) {
+        console.log(
+          '⚠️  Identity discovery by attributes failed (expected in local test environment)'
+        )
+        // Expected to fail in test environment
+        expect(err).toBeDefined()
+      }
+    }, 10000)
+  })
+
+  // ============================================================================
+  //   Transactions
+  // ============================================================================
+
+  describe('Transactions', () => {
+    test('internalizeAction - should internalize an external transaction', async () => {
+      console.log('📥 Testing transaction internalization...')
+      // This is a complex operation that requires an actual external transaction
+      // For testing purposes, we'll try with minimal parameters and expect graceful failure
+      try {
+        const dummyTxHex =
+          '01000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0100ffffffff01000000000000000000000000'
+        const result = await setup.wallet.internalizeAction({
+          tx: Array.from(Buffer.from(dummyTxHex, 'hex')),
+          outputs: [
+            {
+              outputIndex: 0,
+              protocol: 'basket insertion',
+              insertionRemittance: {
+                basket: 'default'
+              }
+            }
+          ],
+          description: 'Test internalization of external transaction'
+        })
+
+        console.log('✅ Transaction internalized successfully')
+        expect(result).toBeDefined()
+      } catch (err: any) {
+        console.log(
+          '⚠️  Transaction internalization failed (expected with dummy data)'
+        )
+        // Expected to fail with dummy data
+        expect(err).toBeDefined()
+      }
+      console.log('✅ Transaction internalization test completed')
+    }, 10000)
+  })
+
+  // ============================================================================
+  // Blockchain Info
+  // ============================================================================
+
+  describe.skip('Blockchain Info', () => {
+    test('getHeight - should fetch current block height', async () => {
+      // Skipped for local storage tests - requires external blockchain API
+    }, 10000)
+
+    test('getHeaderForHeight - should fetch header for specific height', async () => {
+      // Skipped for local storage tests - requires external blockchain API
+    }, 10000)
+  })
+})
diff --git a/src/brc100.py.copy.ts b/src/brc100.py.copy.ts
new file mode 100644
index 0000000..a351db8
--- /dev/null
+++ b/src/brc100.py.copy.ts
@@ -0,0 +1,1286 @@
+import { PrivateKey, Transaction, MerklePath, P2PKH, Beef, PublicKey } from '@bsv/sdk'
+import { Setup, SetupWallet, StorageClient } from '@bsv/wallet-toolbox'
+import { exit } from 'process'
+
+/**
+ * Default py-wallet-toolbox endpoint URL.
+ */
+const DEFAULT_PY_WALLET_TOOLBOX_URL = 'http://localhost:8000'
+
+/**
+ * Track nosend transaction references for cleanup.
+ * Tests that create nosend transactions should add their references here.
+ */
+const pendingAborts: string[] = []
+
+/**
+ * Global flag indicating if we're running in live test mode with funded wallet.
+ */
+const isLiveMode = process.env.LIVE === 'true' || process.env.LIVE === '1'
+
+describe('BRC-100 Wallet Operations (Python Storage Server)', () => {
+  let setup: SetupWallet
+  let walletServiceAvailable = false
+
+  beforeAll(async () => {
+    const endpointUrl =
+      process.env.PY_WALLET_TOOLBOX_URL || DEFAULT_PY_WALLET_TOOLBOX_URL
+    const env = Setup.getEnv('test')
+    // console.log({env})
+    // Determine which key to use
+    let rootKeyHex: string
+    if (isLiveMode && process.env.LIVE_PRIVATE_KEY) {
+      rootKeyHex = process.env.LIVE_PRIVATE_KEY
+      console.log('🔥 LIVE MODE ENABLED - Using funded testnet key')
+      console.log('⚠️  WARNING: This will broadcast real transactions!')
+    } else {
+      rootKeyHex = env.devKeys[env.identityKey]
+      console.log('🧪 TEST MODE - Using development keys')
+    }
+
+    try {
+      // Create wallet without any storage providers
+      setup = await Setup.createWallet({
+        env,
+        rootKeyHex
+      })
+
+      // Reduced verbose logging
+
+      // Create a StorageClient connected to the py-wallet-toolbox storage server
+      const storageClient = new StorageClient(setup.wallet, endpointUrl)
+      await storageClient.makeAvailable()
+      await setup.storage.addWalletStorageProvider(storageClient)
+
+      // Try to connect to verify the service is available
+      await setup.wallet.waitForAuthentication({})
+      walletServiceAvailable = true
+      // console.log({wallet: setup.wallet})
+    } catch (error: any) {
+      walletServiceAvailable = false
+      const errorMessage = error?.message || String(error)
+
+      if (
+        errorMessage.includes('fetch failed') ||
+        errorMessage.includes('ECONNREFUSED') ||
+        errorMessage.includes('Network error')
+      ) {
+        console.error(
+          '\n' +
+          '='.repeat(80) +
+          '\n' +
+          '⚠️  PY WALLET TOOLBOX STORAGE SERVER NOT AVAILABLE\n' +
+          '='.repeat(80) +
+          '\n' +
+          `\nThe py-wallet-toolbox storage server is not running at ${endpointUrl}\n` +
+          '\nTo run these tests, you need to start the py-wallet-toolbox storage server.\n' +
+          '\nSetup steps:\n' +
+          '  1. Navigate to the py-wallet-toolbox directory:\n' +
+          '     cd ../py-wallet-toolbox/examples/storage_server_example\n' +
+          '  2. Activate the virtual environment:\n' +
+          '     source venv/bin/activate  # Linux/Mac\n' +
+          '     # or\n' +
+          '     venv\\Scripts\\activate     # Windows\n' +
+          '  3. Install dependencies:\n' +
+          '     pip install -r requirements.txt\n' +
+          '  4. Run migrations:\n' +
+          '     python manage.py migrate\n' +
+          '  5. Start the storage server:\n' +
+          '     python manage.py runserver\n' +
+          '\nThe server should be available at http://localhost:8000\n' +
+          '\nFor more details, see the py-wallet-toolbox storage server README.md\n' +
+          '\n' +
+          '='.repeat(80) +
+          '\n'
+        )
+
+        // Exit early to prevent running all tests
+        process.exit(1)
+      }
+
+      // Re-throw other errors
+      throw error
+    }
+  }, 10000)
+
+  afterAll(async () => {
+    // Cleanup: Abort any pending transactions we created
+    for (const reference of pendingAborts) {
+      try {
+        await setup.wallet.abortAction({ reference })
+      } catch (err) {
+        // Already aborted or completed - ignore
+      }
+    }
+    pendingAborts.length = 0
+
+    // Cleanup: Remove internalized funding transaction from database
+    // This keeps the test database clean for subsequent runs
+    if (setup && setup.wallet) {
+      // try {
+      //   // List all actions to find the internalized one
+      //   const actions = await setup.wallet.listActions({ labels: [], limit: 100 })
+
+      //   // Find actions with "Auto-internalize funding transaction" description
+      //   const internalizedActions = actions.actions.filter(a =>
+      //     a.description?.includes('Auto-internalize funding transaction')
+      //   )
+      //   // Cleanup handled automatically
+      // } catch (err) {
+      //   // Cleanup is best-effort, don't fail the test suite
+      //   console.log('⚠️  Cleanup note: Internalized transactions remain in database')
+      // }
+    }
+  }, 10000)
+
+  // ============================================================================
+  //   Basics
+  // ============================================================================
+
+  describe('Basics', () => {
+    test('walletInfo - should retrieve wallet address and balance', async () => {
+      // Test balance retrieval
+      let balance = 0
+      try {
+        balance = await setup.wallet.balance()
+        console.log({ balance })
+        expect(typeof balance).toBe('number')
+        expect(balance).toBeGreaterThanOrEqual(0)
+
+
+        if (isLiveMode && balance === 0) {
+          // Try to internalize funding automatically in live mode
+          try {
+
+            // console.log('💰 Balance is 0, requesting derived key for external P2PKH funding...')
+
+            // Generate derivation prefix and suffix for BRC-29
+            // Match Python example: "faucet-prefix-01" / "faucet-suffix-01"
+            // IMPORTANT: These must be base64-encoded for the keyID used in getPublicKey
+            // because validation uses base64 strings directly (matches Go/TS behavior)
+            const FAUCET_DERIVATION_PREFIX = "faucet-prefix-01"
+            const FAUCET_DERIVATION_SUFFIX = "faucet-suffix-01"
+            const derivationPrefixB64 = Buffer.from(FAUCET_DERIVATION_PREFIX, 'utf-8').toString('base64')
+            const derivationSuffixB64 = Buffer.from(FAUCET_DERIVATION_SUFFIX, 'utf-8').toString('base64')
+            // Use base64 strings in keyID to match validation behavior (Go/TS use base64 strings directly)
+            const keyID = `${derivationPrefixB64} ${derivationSuffixB64}`
+
+            // Use AnyoneKey as sender (matches Python example)
+            // AnyoneKey = PrivateKey(1).public_key()
+            // PrivateKey(1) in hex is 32 bytes with value 1: '0000000000000000000000000000000000000000000000000000000000000001'
+            const anyoneKeyPriv = PrivateKey.fromString('0000000000000000000000000000000000000000000000000000000000000001')
+            const anyoneKey = anyoneKeyPriv.toPublicKey()
+            const anyoneKeyHex = anyoneKey.toString()
+
+            // Request derived public key using BRC-29 protocol (wallet payment protocol)
+            // Use AnyoneKey as counterparty (external sender, like a faucet)
+            // NOTE: keyID uses base64 strings to match validation behavior
+            // NOTE: forSelf=true to match AddressForSelf direction (recipient derives for self)
+            // This matches validation which uses derivePrivateKey (recipient's perspective)
+            const derivedKeyResult = await setup.wallet.getPublicKey({
+              protocolID: [2, '3241645161d8'], // BRC-29 wallet payment protocol
+              keyID: keyID, // Base64 strings (matches Go/TS validation)
+              counterparty: anyoneKeyHex, // Use AnyoneKey for external sender (faucet)
+              forSelf: true // CRITICAL: Must be true to match AddressForSelf direction
+            })
+
+            if (!derivedKeyResult.publicKey) {
+              throw new Error('Failed to get derived public key from wallet')
+            }
+
+            // Create P2PKH address from derived public key
+            const derivedPublicKey = PublicKey.fromString(derivedKeyResult.publicKey)
+            const network = setup.chain === 'main' ? 'mainnet' : 'testnet'
+            const fundingAddress = derivedPublicKey.toAddress(network)
+            // console.log('📬 EXTERNAL FUNDING ADDRESS (P2PKH)')
+            console.log('Address:', fundingAddress)
+
+            // Check if the funding address has funds via Whatsonchain API
+            const wocNetwork = setup.chain === 'main' ? 'main' : 'test'
+            const wocBaseUrl = `https://api.whatsonchain.com/v1/bsv/${wocNetwork}`
+
+            try {
+              // Check for unspent outputs at this address
+              const unspentResponse = await fetch(`${wocBaseUrl}/address/${fundingAddress}/unspent`)
+              if (!unspentResponse.ok) {
+                throw new Error(`Whatsonchain API error: ${unspentResponse.statusText}`)
+              }
+
+              const unspentData = await unspentResponse.json()
+              console.log(`📊 Found ${unspentData.length} unspent output(s) at funding address`)
+
+              if (unspentData.length > 0) {
+                // Get the first unspent output (or we could process all of them)
+                const firstUtxo = unspentData[0]
+                const txid = firstUtxo.tx_hash
+                const outputIndex = firstUtxo.tx_pos
+
+                // console.log(`📥 Found funding transaction: ${txid}:${outputIndex}`)
+                // console.log(`💰 Amount: ${firstUtxo.value} satoshis`)
+                
+                // Show Whatsonchain link for the funding transaction
+                const wocNetwork = setup.chain === 'main' ? '' : 'test.'
+                const fundingTxUrl = `https://${wocNetwork}whatsonchain.com/tx/${txid}`
+                console.log(`🔗 View funding transaction on Whatsonchain: ${fundingTxUrl}`)
+
+                // Get the raw transaction hex
+                const txResponse = await fetch(`${wocBaseUrl}/tx/${txid}/hex`)
+                if (!txResponse.ok) {
+                  throw new Error(`Failed to fetch transaction: ${txResponse.statusText}`)
+                }
+
+                const txHex = await txResponse.text()
+                // console.log(`📄 Retrieved raw transaction (${txHex.length / 2} bytes)`)
+
+                // Parse the transaction to verify the output
+                const txBytes = Array.from(Buffer.from(txHex, 'hex'))
+                const tx = Transaction.fromBinary(txBytes)
+
+                // Verify the output at the specified index pays to our address
+                if (outputIndex >= tx.outputs.length) {
+                  throw new Error(`Output index ${outputIndex} out of range (${tx.outputs.length} outputs)`)
+                }
+
+                const output = tx.outputs[outputIndex]
+                // Verify the output pays to our address by comparing locking scripts
+                const expectedLockingScript = new P2PKH().lock(fundingAddress)
+                const actualLockingScript = output.lockingScript.toHex()
+                const expectedLockingScriptHex = expectedLockingScript.toHex()
+                
+                console.log(`   Output ${outputIndex} locking script: ${actualLockingScript}`)
+                console.log(`   Expected locking script: ${expectedLockingScriptHex}`)
+                
+                if (actualLockingScript !== expectedLockingScriptHex) {
+                  console.log(`⚠️  Warning: Output ${outputIndex} locking script does not match funding address`)
+                  console.log(`   This output may not be a BRC-29 wallet payment - it might be a regular P2PKH`)
+                  // Continue anyway - might be a different output format
+                } else {
+                  console.log(`✅ Output ${outputIndex} locking script matches funding address`)
+                }
+
+                // Fetch merkle proof (BUMP) from Whatsonchain to build valid AtomicBEEF
+                console.log('🔍 Fetching merkle proof from Whatsonchain...')
+                let merklePath: MerklePath | null = null
+                try {
+                  const proofResponse = await fetch(`${wocBaseUrl}/tx/${txid}/proof/tsc`)
+                  console.log(`   Proof response status: ${proofResponse.status}`)
+                  
+                  if (proofResponse.ok) {
+                    const proofResponseData = await proofResponse.json()
+                    console.log(`   Proof response type:`, Array.isArray(proofResponseData) ? 'array' : typeof proofResponseData)
+                    console.log(`   Proof response data:`, JSON.stringify(proofResponseData, null, 2).substring(0, 500))
+                    if (proofResponseData !== null && typeof proofResponseData === 'object') {
+                      console.log(`   Proof response keys:`, Array.isArray(proofResponseData) ? `array[${proofResponseData.length}]` : Object.keys(proofResponseData))
+                    }
+                    
+                    // Whatsonchain may return an array of proofs or a single proof object
+                    let proofData: any = null
+                    if (Array.isArray(proofResponseData)) {
+                      if (proofResponseData.length === 0) {
+                        console.log(`⚠️  Proof response is an empty array`)
+                      } else {
+                        proofData = proofResponseData[0]
+                      }
+                    } else if (typeof proofResponseData === 'object' && proofResponseData !== null) {
+                      // Single proof object
+                      proofData = proofResponseData
+                    }
+                    
+                    if (proofData) {
+                      console.log(`   Proof data keys:`, Object.keys(proofData))
+                      console.log(`   Proof data structure:`, { 
+                        hasIndex: proofData.index !== undefined, 
+                        hasNodes: Array.isArray(proofData.nodes),
+                        nodesCount: proofData.nodes?.length,
+                        hasTarget: proofData.target !== undefined,
+                        hasTxOrId: proofData.txOrId !== undefined,
+                        proofDataValue: JSON.stringify(proofData).substring(0, 200)
+                      })
+                      
+                      // Get transaction info to get block height
+                      const txInfoResponse = await fetch(`${wocBaseUrl}/tx/${txid}`)
+                      console.log(`   TX info response status: ${txInfoResponse.status}`)
+                      
+                      if (txInfoResponse.ok) {
+                        const txInfo = await txInfoResponse.json()
+                        const blockHeight = txInfo.blockheight
+                        console.log(`   Block height: ${blockHeight}`)
+                        
+                        if (blockHeight && proofData.nodes && Array.isArray(proofData.nodes) && proofData.nodes.length > 0 && proofData.index !== undefined) {
+                        try {
+                          // Convert TSC proof to MerklePath format
+                          // Based on go-wallet-toolbox/pkg/internal/txutils/proof_for_merkle_path.go
+                          const index = proofData.index
+                          const nodes = proofData.nodes
+                          const treeHeight = nodes.length
+                          
+                          console.log(`   Converting TSC proof: index=${index}, treeHeight=${treeHeight}`)
+                          
+                          // Build path levels
+                          const path: Array<Array<{ offset: number; hash?: string; txid?: boolean; duplicate?: boolean }>> = []
+                          let currentIndex = index
+                          
+                          for (let level = 0; level < treeHeight; level++) {
+                            const node = nodes[level]
+                            const isOdd = currentIndex % 2 === 1
+                            const siblingOffset = isOdd ? currentIndex - 1 : currentIndex + 1
+                            
+                            const levelPath: Array<{ offset: number; hash?: string; txid?: boolean; duplicate?: boolean }> = []
+                            
+                            // Add sibling node
+                            if (node === '*' || (level === 0 && node === txid)) {
+                              levelPath.push({ offset: siblingOffset, duplicate: true })
+                            } else {
+                              levelPath.push({ offset: siblingOffset, hash: node })
+                            }
+                            
+                            // At level 0, add txid leaf
+                            if (level === 0) {
+                              const txidLeaf = { offset: index, hash: txid, txid: true }
+                              if (isOdd) {
+                                levelPath.push(txidLeaf)
+                              } else {
+                                levelPath.unshift(txidLeaf)
+                              }
+                            }
+                            
+                            path.push(levelPath)
+                            currentIndex = currentIndex >> 1
+                          }
+                          
+                          // Create MerklePath with legalOffsetsOnly=false to avoid strict validation
+                          merklePath = new MerklePath(blockHeight, path, false)
+                          console.log(`✅ Retrieved merkle proof for block height ${blockHeight}, path levels: ${path.length}`)
+                        } catch (mpErr: any) {
+                          console.log(`⚠️  Failed to create MerklePath: ${mpErr.message}`)
+                          console.log(`   Error details:`, mpErr)
+                        }
+                        } else {
+                          console.log(`⚠️  Missing required data: blockHeight=${blockHeight}, hasNodes=${Array.isArray(proofData.nodes)}, nodesLength=${proofData.nodes?.length}, hasIndex=${proofData.index !== undefined}`)
+                        }
+                      } else {
+                        console.log(`⚠️  Failed to fetch TX info: ${txInfoResponse.status} ${txInfoResponse.statusText}`)
+                      }
+                    }
+                  } else {
+                    console.log(`⚠️  Failed to fetch proof: ${proofResponse.status} ${proofResponse.statusText}`)
+                    const errorText = await proofResponse.text()
+                    console.log(`   Error response: ${errorText.substring(0, 200)}`)
+                  }
+                } catch (proofErr: any) {
+                  console.log(`⚠️  Could not fetch merkle proof: ${proofErr.message}`)
+                  console.log(`   Error stack:`, proofErr.stack)
+                  console.log('   Will attempt to build BEEF without merkle proof (may fail validation)')
+                }
+
+                // Build AtomicBEEF with transaction and merkle proof
+                // If we have a merkle path, attach it to the transaction
+                if (merklePath) {
+                  tx.merklePath = merklePath
+                  console.log(`✅ Attached merkle proof to transaction`)
+                } else {
+                  console.log(`⚠️  No merkle path available - BEEF will be invalid`)
+                }
+                
+                const beef = new Beef()
+                // Merge transaction (will automatically merge merkle path if attached)
+                beef.mergeTransaction(tx)
+                console.log(`   BEEF after merge: ${beef.bumps.length} BUMPS, ${beef.txs.length} transactions`)
+
+                try {
+                  // Prepare payment remittance with proper base64 encoding
+                  // Match Python example: use AnyoneKey as senderIdentityKey (external sender/faucet)
+                  // NOTE: derivationPrefix and derivationSuffix are already base64-encoded above
+                  const paymentRemittance = {
+                    derivationPrefix: derivationPrefixB64, // Already base64-encoded
+                    derivationSuffix: derivationSuffixB64, // Already base64-encoded
+                    senderIdentityKey: anyoneKeyHex // Use AnyoneKey (external sender, like faucet)
+                  }
+                  
+                  console.log(`   Payment remittance:`, {
+                    derivationPrefix: paymentRemittance.derivationPrefix,
+                    derivationSuffix: paymentRemittance.derivationSuffix,
+                    derivationPrefixDecoded: Buffer.from(paymentRemittance.derivationPrefix, 'base64').toString('utf-8'),
+                    derivationSuffixDecoded: Buffer.from(paymentRemittance.derivationSuffix, 'base64').toString('utf-8'),
+                    senderIdentityKey: paymentRemittance.senderIdentityKey.substring(0, 20) + '... (AnyoneKey)'
+                  })
+                  
+                  // Internalize as "wallet payment" protocol (matches Python example)
+                  // Python example always uses "wallet payment" protocol with paymentRemittance
+                  const internalizeResult = await setup.wallet.internalizeAction({
+                    tx: beef.toBinaryAtomic(txid),
+                    outputs: [
+                      {
+                        outputIndex: outputIndex,
+                        protocol: 'wallet payment',
+                        paymentRemittance: paymentRemittance
+                      }
+                    ],
+                    description: 'Auto-internalize funding transaction'
+                  })
+                  
+                  console.log('✅ Successfully internalized as wallet payment')
+                  
+                  if (internalizeResult) {
+                    console.log(`✅ Successfully internalized funding transaction`)
+                    console.log(`   Accepted: ${internalizeResult.accepted}`)
+                    console.log(`   TXID: ${txid}`)
+                    
+                    // Show Whatsonchain link
+                    const wocNetwork = setup.chain === 'main' ? '' : 'test.'
+                    const fundingTxUrl = `https://${wocNetwork}whatsonchain.com/tx/${txid}`
+                    console.log(`🔗 View funding transaction on Whatsonchain: ${fundingTxUrl}`)
+
+                    // Check balance again after internalization
+                    const newBalance = await setup.wallet.balance()
+                    console.log(`💰 New balance after internalization: ${newBalance} satoshis`)
+                  }
+                } catch (internalizeErr: any) {
+                  // Final fallback - log and continue
+                  console.log('⚠️  Could not internalize transaction:', internalizeErr.message)
+                  
+                  if (internalizeErr.message.includes('BRC-29') || internalizeErr.message.includes('locking script')) {
+                    console.log('   The output is a regular P2PKH (not created with BRC-29)')
+                    console.log('   The wallet may still be able to spend it if it can derive the private key')
+                  } else if (internalizeErr.message.includes('AtomicBEEF')) {
+                    console.log('   The BEEF may be missing merkle proofs (BUMPS)')
+                    console.log('   This is expected when fetching transactions from external APIs')
+                  }
+                  
+                  console.log('   This is best-effort automatic funding - continuing without internalization')
+                  // Continue without exiting - this is best-effort automatic funding
+                }
+              } else {
+                console.log('ℹ️  No unspent outputs found at funding address')
+              }
+            } catch (apiErr: any) {
+              console.log('   Could not check external API:', apiErr.message)
+              // Don't throw - this is best-effort automatic funding
+              // Continue without exiting
+            }
+          } catch (apiErr) {
+            console.log('   Could not check external API')
+          }
+        }
+      } catch (err: any) {
+        console.log('⚠️  Balance check failed (expected for local testing)')
+        if (isLiveMode) {
+          console.log(
+            '   This may indicate services are not configured for live testing.'
+          )
+        }
+        // Balance might fail if services not configured, but that's expected
+      }
+      // Test completed
+    }, 10000)
+
+    // test('waitForAuthentication - should resolve immediately for base wallet', async () => {
+    //   console.log('🔐 Testing waitForAuthentication...')
+    //   const result = await setup.wallet.waitForAuthentication({})
+    //   console.log(`🔐 Authentication result: ${JSON.stringify(result)}`)
+    //   expect(result).toBeDefined()
+    //   expect(result.authenticated).toBeDefined()
+    //   // Base wallet resolves immediately
+    //   console.log('✅ waitForAuthentication test completed')
+    // }, 10000)
+
+    // test('isAuthenticated - should check if wallet is authenticated', async () => {
+    //   console.log('🔐 Testing isAuthenticated...')
+    //   const result = await setup.wallet.isAuthenticated({})
+    //   console.log(`🔐 Authentication check result: ${JSON.stringify(result)}`)
+    //   expect(result).toBeDefined()
+    //   expect(result.authenticated).toBeDefined()
+    //   expect(typeof result.authenticated).toBe('boolean')
+    //   console.log('✅ isAuthenticated test completed')
+    // }, 10000)
+
+    // test('getNetwork - should return the network information', async () => {
+    //   console.log('🌐 Testing getNetwork...')
+    //   const result = await setup.wallet.getNetwork({})
+    //   console.log(`🌐 Network info: ${JSON.stringify(result)}`)
+    //   expect(result).toBeDefined()
+    //   expect(result.network).toBeDefined()
+    //   expect(['main', 'test', 'testnet']).toContain(result.network)
+    //   console.log('✅ getNetwork test completed')
+    // }, 10000)
+
+    // test('getVersion - should return wallet version information', async () => {
+    //   console.log('📦 Testing getVersion...')
+    //   const result = await setup.wallet.getVersion({})
+    //   console.log(`📦 Version info: ${JSON.stringify(result)}`)
+    //   expect(result).toBeDefined()
+    //   expect(result.version).toBeDefined()
+    //   expect(typeof result.version).toBe('string')
+    //   console.log('✅ getVersion test completed')
+    // }, 10000)
+  })
+
+  // ============================================================================
+  // Keys and Signatures
+  // ============================================================================
+
+  describe('Keys and Signatures', () => {
+    // test('getPublicKey - should derive protocol-specific public key', async () => {
+    //   console.log('🔑 Testing public key derivation...')
+    //   const result = await setup.wallet.getPublicKey({
+    //     identityKey: true,
+    //     protocolID: [0, 'testprotocol'],
+    //     keyID: '1',
+    //     counterparty: 'self'
+    //   })
+
+    //   console.log(
+    //     `🔑 Derived public key: ${result.publicKey.substring(0, 20)}...`
+    //   )
+    //   expect(result).toBeDefined()
+    //   expect(result.publicKey).toBeDefined()
+    //   expect(typeof result.publicKey).toBe('string')
+    //   expect(result.publicKey.length).toBeGreaterThan(60) // Public key length
+    //   console.log('✅ Public key test completed')
+    // }, 10000)
+
+    // test('createSignature - should sign data with wallet keys', async () => {
+    //   console.log('✍️  Testing signature creation...')
+    //   const testMessage = 'Hello, BSV!'
+    //   const data = Array.from(Buffer.from(testMessage))
+
+    //   const result = await setup.wallet.createSignature({
+    //     data,
+    //     protocolID: [0, 'testprotocol'],
+    //     keyID: '1',
+    //     counterparty: 'self'
+    //   })
+    //   console.log(
+    //     `✍️  Created signature: ${Buffer.from(result.signature.slice(0, 10)).toString('hex')}...`
+    //   )
+    //   expect(result).toBeDefined()
+    //   expect(result.signature).toBeDefined()
+    //   console.log('✅ Signature creation test completed')
+    // }, 10000)
+
+    // test('verifySignature - should create and verify signature round-trip', async () => {
+    //   console.log('🔍 Testing signature verification...')
+    //   const testMessage = 'Test signature verification'
+    //   const data = Array.from(Buffer.from(testMessage))
+
+    //   // Create signature
+    //   const createResult = await setup.wallet.createSignature({
+    //     data,
+    //     protocolID: [0, 'testprotocol'],
+    //     keyID: '1',
+    //     counterparty: 'self'
+    //   })
+
+    //   // Verify signature
+    //   const verifyResult = await setup.wallet.verifySignature({
+    //     data,
+    //     signature: createResult.signature,
+    //     protocolID: [0, 'testprotocol'],
+    //     keyID: '1',
+    //     counterparty: 'self'
+    //   })
+
+    //   console.log(`🔍 Signature verification result: ${verifyResult.valid}`)
+    //   expect(verifyResult).toBeDefined()
+    //   expect(verifyResult.valid).toBe(true)
+    //   console.log('✅ Signature verification test completed')
+    // }, 10000)
+
+    // test('revealCounterpartyKeyLinkage - should reveal counterparty key linkage', async () => {
+    //   try {
+    //     const result = await setup.wallet.revealCounterpartyKeyLinkage({
+    //       counterparty: 'self',
+    //       verifier: '02' + 'a'.repeat(64), // demo verifier pubkey
+    //       privilegedReason: 'Demo'
+    //     })
+
+    //     expect(result).toBeDefined()
+    //     expect(result.prover).toBeDefined()
+    //     expect(result.counterparty).toBeDefined()
+    //   } catch (err: any) {
+    //     // This might fail in test environments, which is expected
+    //   }
+    // }, 10000)
+
+    // test('revealSpecificKeyLinkage - should reveal specific key linkage', async () => {
+    //   try {
+    //     const result = await setup.wallet.revealSpecificKeyLinkage({
+    //       counterparty: 'self',
+    //       verifier: '02' + 'a'.repeat(64), // demo verifier pubkey
+    //       protocolID: [0, 'testprotocol'],
+    //       keyID: '1',
+    //       privilegedReason: 'Demo'
+    //     })
+
+    //     expect(result).toBeDefined()
+    //     expect(result.prover).toBeDefined()
+    //     expect(result.counterparty).toBeDefined()
+    //     expect(result.protocolID).toBeDefined()
+    //     expect(result.keyID).toBeDefined()
+    //   } catch (err: any) {
+    //     // This might fail in test environments, which is expected
+    //   }
+    // }, 10000)
+  })
+
+  // // ============================================================================
+  // // Crypto Operations
+  // // ============================================================================
+
+  // describe('Crypto Operations', () => {
+  //   test('createHmac - should generate HMAC for message', async () => {
+  //     console.log('🔐 Testing HMAC creation...')
+  //     const testMessage = 'Hello, HMAC!'
+  //     const data = Array.from(Buffer.from(testMessage))
+
+  //     const result = await setup.wallet.createHmac({
+  //       data,
+  //       protocolID: [0, 'testprotocol'],
+  //       keyID: '1',
+  //       counterparty: 'self'
+  //     })
+
+  //     console.log(
+  //       `🔐 Generated HMAC: ${Buffer.from(result.hmac.slice(0, 10)).toString('hex')}...`
+  //     )
+  //     expect(result).toBeDefined()
+  //     expect(result.hmac).toBeDefined()
+  //     console.log('✅ HMAC creation test completed')
+  //   }, 10000)
+
+  //   test('verifyHmac - should create and verify HMAC round-trip', async () => {
+  //     console.log('🔍 Testing HMAC verification...')
+  //     const testMessage = 'Test HMAC verification'
+  //     const data = Array.from(Buffer.from(testMessage))
+
+  //     // Create HMAC
+  //     const createResult = await setup.wallet.createHmac({
+  //       data,
+  //       protocolID: [0, 'testprotocol'],
+  //       keyID: '1',
+  //       counterparty: 'self'
+  //     })
+
+  //     // Verify HMAC
+  //     const verifyResult = await setup.wallet.verifyHmac({
+  //       data,
+  //       hmac: createResult.hmac,
+  //       protocolID: [0, 'testprotocol'],
+  //       keyID: '1',
+  //       counterparty: 'self'
+  //     })
+
+  //     console.log(`🔍 HMAC verification result: ${verifyResult.valid}`)
+  //     console.log('✅ HMAC verification test completed')
+  //     expect(verifyResult).toBeDefined()
+  //     expect(verifyResult.valid).toBe(true)
+  //     console.log('✅ HMAC verification test completed')
+  //   }, 10000)
+
+  //   test('encrypt/decrypt - should encrypt data and decrypt it back', async () => {
+  //     console.log('🔒 Testing encryption/decryption...')
+  //     const testMessage = 'Secret Message!'
+  //     const plaintext = Array.from(Buffer.from(testMessage))
+
+  //     // Encrypt
+  //     const encryptResult = await setup.wallet.encrypt({
+  //       plaintext,
+  //       protocolID: [0, 'encryption'],
+  //       keyID: '1',
+  //       counterparty: 'self'
+  //     })
+
+  //     console.log(
+  //       `🔒 Encrypted message: ${Buffer.from(encryptResult.ciphertext.slice(0, 10)).toString('hex')}...`
+  //     )
+  //     expect(encryptResult).toBeDefined()
+  //     expect(encryptResult.ciphertext).toBeDefined()
+
+  //     // Decrypt
+  //     const decryptResult = await setup.wallet.decrypt({
+  //       ciphertext: encryptResult.ciphertext,
+  //       protocolID: [0, 'encryption'],
+  //       keyID: '1',
+  //       counterparty: 'self'
+  //     })
+
+  //     expect(decryptResult).toBeDefined()
+  //     expect(decryptResult.plaintext).toBeDefined()
+  //     expect(Array.isArray(decryptResult.plaintext)).toBe(true)
+
+  //     // Verify decrypted message matches original
+  //     const decrypted = Buffer.from(decryptResult.plaintext).toString()
+  //     console.log(`🔓 Decrypted message: "${decrypted}"`)
+  //     expect(decrypted).toBe(testMessage)
+  //     console.log('✅ Encryption/decryption test completed')
+  //   }, 10000)
+  // })
+
+  // ============================================================================
+  // Actions
+  // ============================================================================
+
+  describe('Actions', () => {
+    test('createAction - should create OP_RETURN transaction (noSend + abort)', async () => {
+      console.log(`Starting createAction test ${isLiveMode ? '(LIVE)' : '(test mode)'}`)
+
+      // Check balance first - need at least 10 sats to safely run this test
+      // For externally-funded outputs, also check the 'funding' basket
+      let balance = 0
+      try {
+        balance = await setup.wallet.balance()
+        console.log({ balance })
+       
+      } catch (err) {
+        console.log('⚠️  Could not check balance - assuming 0')
+      }
+
+      const requiredBalance = 10
+      if (balance < requiredBalance) {
+        if (isLiveMode) {
+          console.log(
+            `❌ LIVE MODE: Insufficient balance (${balance} < ${requiredBalance} sats)`
+          )
+          console.log('   Fund your wallet before running live tests.')
+          throw new Error('Insufficient funds for live testing')
+        } else {
+          console.log('⚠️  Skipping test - insufficient balance')
+          return
+        }
+      }
+
+      try {
+        const message =
+          'Hello, World! - Test Action' + (isLiveMode ? ' (LIVE)' : '')
+        const messageBytes = Buffer.from(message)
+        const hexData = messageBytes.toString('hex')
+        const length = messageBytes.length
+        const lockingScript = `006a${length.toString(16).padStart(2, '0')}${hexData}`
+
+        const shouldBroadcast = isLiveMode
+        let action: any
+        try {
+          action = await setup.wallet.createAction({
+            description: `Test action: ${message}`,
+            outputs: [
+              { lockingScript, satoshis: 0, outputDescription: 'Test output', basket: 'opreturn', tags: ['test'] }
+            ],
+            labels: ['test:create_action'],
+            options: { 
+              noSend: !shouldBroadcast,
+              // In live mode, disable delayed broadcast to ensure immediate broadcasting
+              acceptDelayedBroadcast: shouldBroadcast ? false : true
+            }
+          })
+          console.dir(action, { depth: null })
+        } catch (error: any) {
+          // When acceptDelayedBroadcast is false, unsuccessful results throw WERR_REVIEW_ACTIONS
+          // Extract the results from the error and treat as action result
+          if (error.name === 'WERR_REVIEW_ACTIONS' || error.message?.includes('require review')) {
+            console.log('⚠️  Action requires review (undelayed mode)')
+            action = {
+              txid: error.txid,
+              tx: error.tx,
+              sendWithResults: error.sendWithResults || [],
+              reviewActionResults: error.reviewActionResults || [],
+              noSendChange: error.noSendChange
+            }
+            console.dir(action, { depth: null })
+            
+            // Log review results
+            if (action.reviewActionResults && action.reviewActionResults.length > 0) {
+              console.log('📋 Review action results:')
+              action.reviewActionResults.forEach((result: any) => {
+                console.log(`   ${result.txid}: ${result.status}`)
+                if (result.competingTxs && result.competingTxs.length > 0) {
+                  console.log(`     Competing transactions: ${result.competingTxs.join(', ')}`)
+                }
+              })
+            }
+          } else {
+            // Some other error - log details and rethrow
+            console.error('❌ createAction failed with error:', error.name || error.constructor?.name)
+            console.error('   Message:', error.message)
+            if (error.stack) {
+              console.error('   Stack:', error.stack)
+            }
+            // Check for script evaluation errors
+            if (error.message && (error.message.includes('OP_EQUALVERIFY') || error.message.includes('Script evaluation'))) {
+              console.error('🔍 Script evaluation error detected - this usually means the unlocking script does not match the locking script')
+              console.error('   This can happen if:')
+              console.error('   1. The derivation fields (derivationPrefix/derivationSuffix) do not match the public key in the locking script')
+              console.error('   2. The counterparty type (SELF vs OTHER) is incorrect')
+              console.error('   3. The identity key used for derivation does not match')
+              console.error('   4. The output was internalized incorrectly (wrong protocol or missing derivation data)')
+            }
+            throw error
+          }
+        }
+        
+        // Add Whatsonchain link if txid is available
+        if (action.txid) {
+          const chain = setup.wallet.chain || 'test'
+          const network = chain === 'main' ? '' : 'test.'
+          const whatsonchainUrl = `https://${network}whatsonchain.com/tx/${action.txid}`
+          console.log(`\n🔗 View transaction on Whatsonchain: ${whatsonchainUrl}\n`)
+        }
+        
+        // Also show links for sendWithResults if available
+        if (action.sendWithResults && Array.isArray(action.sendWithResults)) {
+          action.sendWithResults.forEach((result: any) => {
+            if (result.status!=='failed' && result.txid) {
+              const chain = setup.wallet.chain || 'test'
+              const network = chain === 'main' ? '' : 'test.'
+              const whatsonchainUrl = `https://${network}whatsonchain.com/tx/${result.txid}`
+              console.log(`🔗 View transaction ${result.txid} on Whatsonchain: ${whatsonchainUrl}`)
+            }else 
+            console.log(`   Status: ${result.status}`)
+            throw new Error(`Transaction ${result.txid} failed with status ${result.status}`)
+          })
+        }
+//        console.log(`✅ Action created with ${action.signableTransaction ? 'signableTransaction' : action.txid ? 'txid' : 'unknown'}`)
+
+      } catch (err: any) {
+        if (
+          err.message.includes('Insufficient funds') ||
+          err.message.includes('insufficient')
+        )
+          return
+        throw err
+      }
+    }, 15000)
+
+    // test('createAction - verify action result structure', async () => {
+    //   // Check balance first
+    //   let balance = 0
+    //   try {
+    //     balance = await setup.wallet.balance()
+    //     console.log(`💰 Current balance: ${balance} satoshis`)
+    //   } catch (err) {
+    //     console.log('⚠️  Could not check balance - assuming 0')
+    //   }
+
+    //   if (balance < 10 && !isLiveMode) {
+    //     console.log('⚠️  Skipping structure test - insufficient balance')
+    //     return
+    //   }
+
+    //   try {
+    //     const message = 'Structure Test' + (isLiveMode ? ' (LIVE)' : '')
+    //     const messageBytes = Buffer.from(message)
+    //     const hexData = messageBytes.toString('hex')
+    //     const length = messageBytes.length
+    //     const lockingScript = `006a${length.toString(16).padStart(2, '0')}${hexData}`
+
+    //     const shouldBroadcast = isLiveMode && balance >= 10
+    //     console.log(`✍️  Creating structure test action: "${message}"`)
+    //     console.log(
+    //       `${shouldBroadcast ? '📡 BROADCASTING' : '🧪 NO-SEND MODE'} transaction...`
+    //     )
+
+    //     let action
+    //     try {
+    //       console.log('🚀 Calling setup.wallet.createAction (structure test)...')
+    //       action = await setup.wallet.createAction({
+    //         description: `Structure test: ${message}`,
+    //         outputs: [
+    //           {
+    //             lockingScript,
+    //             satoshis: 0,
+    //             outputDescription: 'Test output',
+    //             basket: 'opreturn',
+    //             tags: ['test', ...(isLiveMode ? ['live-test'] : ['test-nosend'])]
+    //           }
+    //         ],
+    //         labels: ['test:structure'],
+    //         options: {
+    //           noSend: !shouldBroadcast
+    //         }
+    //       })
+    //       console.log('✅ Structure test createAction succeeded')
+
+    //       // Log detailed response from server
+    //       console.log('📋 Structure test server response details:')
+    //       console.log('   Full action object:', JSON.stringify(action, null, 2))
+
+    //       if (action.txid) {
+    //         console.log(`   ✅ Transaction ID: ${action.txid}`)
+    //       }
+
+    //       if (action.signableTransaction) {
+    //         console.log('   📝 Signable transaction present')
+    //         console.log('   Reference:', action.signableTransaction.reference)
+    //         console.log('   Input count:', action.signableTransaction.inputs?.length || 0)
+    //         console.log('   Output count:', action.signableTransaction.outputs?.length || 0)
+    //       }
+
+    //       if (action.noSendChange) {
+    //         console.log('   💰 Change outputs:', action.noSendChange.length)
+    //       }
+
+    //     } catch (err: any) {
+    //       console.log('❌ Structure test createAction failed with error:', err.message)
+    //       console.log('   Error code:', err.code)
+    //       console.log('   Error name:', err.name)
+    //       console.log('   Full error object:', JSON.stringify(err, Object.getOwnPropertyNames(err), 2))
+    //       console.log('   Error stack:', err.stack)
+
+    //       // Try to extract more details from the error
+    //       if (err.response) {
+    //         console.log('   Response status:', err.response.status)
+    //         console.log('   Response data:', err.response.data)
+    //       }
+
+    //       throw err
+    //     }
+
+    //     console.log(
+    //       `✅ Structure test action created with ${action.signableTransaction ? 'signableTransaction' : action.txid ? 'txid' : 'unknown'}`
+    //     )
+    //     expect(action).toBeDefined()
+
+    //     if (shouldBroadcast) {
+    //       // In live mode, expect txid
+    //       expect(action.txid).toBeDefined()
+    //       expect(typeof action.txid).toBe('string')
+    //       expect(action.txid!.length).toBe(64)
+    //       console.log(`📡 Transaction broadcasted! TXID: ${action.txid}`)
+    //       console.log(
+    //         `🔗 View on explorer: https://test.whatsonchain.com/tx/${action.txid}`
+    //       )
+    //     } else {
+    //       // Verify result structure - either signableTransaction or txid
+    //       if (action.signableTransaction) {
+    //         expect(action.signableTransaction.reference).toBeDefined()
+    //         expect(action.signableTransaction.tx).toBeDefined()
+    //         console.log(
+    //           `📝 Keeping action ${action.signableTransaction.reference} for database verification`
+    //         )
+    //         // Keep this action for the listActions test to find it
+    //         // Don't abort immediately - will be cleaned up in afterAll
+    //       } else if (action.txid) {
+    //         expect(typeof action.txid).toBe('string')
+    //         expect(action.txid!.length).toBe(64)
+    //       } else {
+    //         throw new Error('Expected either signableTransaction or txid')
+    //       }
+    //     }
+    //   } catch (err: any) {
+    //     if (
+    //       err.message.includes('Insufficient funds') ||
+    //       err.message.includes('insufficient')
+    //     )
+    //       return
+    //     throw err
+    //   }
+    // }, 15000)
+
+    // test('listActions - should list recent wallet actions', async () => {
+    //   console.log(
+    //     '🔍 Checking for actions in database before action creation tests...'
+    //   )
+    //   const actions = await setup.wallet.listActions({
+    //     labels: [],
+    //     limit: 10,
+    //     includeLabels: true
+    //   })
+
+    //   console.log(`📋 Listed ${actions.actions.length} actions from database`)
+    //   if (actions.actions.length > 0) {
+    //     console.log(`   First action: ${actions.actions[0].description}`)
+    //   }
+
+    //   expect(actions).toBeDefined()
+    //   expect(actions.actions).toBeDefined()
+    //   expect(Array.isArray(actions.actions)).toBe(true)
+    //   expect(actions.actions.length).toBeGreaterThanOrEqual(0)
+    // }, 10000)
+
+    // test('abortAction - should abort an unsigned action if available', async () => {
+    //   console.log('🗑️  Testing action abortion...')
+    //   // Check if there are any unsigned actions we can abort
+    //   const actions = await setup.wallet.listActions({ labels: [], limit: 20 })
+    //   const unsignedAction = actions.actions.find(
+    //     a => a.status === 'unsigned' || a.status === 'nosend'
+    //   )
+
+    //   console.log(
+    //     `📋 Found ${actions.actions.length} total actions, ${unsignedAction ? 1 : 0} unsigned`
+    //   )
+    //   // listActions doesn't return references, so we can only abort
+    //   // actions we created in the same session with signableTransaction
+    //   expect(unsignedAction === undefined || unsignedAction.status).toBeTruthy()
+    //   console.log('✅ Action abortion test completed')
+    // }, 10000)
+  })
+
+  // ============================================================================
+  // Outputs
+  // ============================================================================
+
+  // describe('Outputs', () => {
+  //   test('listOutputs - should list wallet outputs', async () => {
+  //     const outputs = await setup.wallet.listOutputs({
+  //       basket: 'default',
+  //       limit: 10,
+  //       offset: 0
+  //     })
+
+  //     console.log(
+  //       `💰 Listed ${outputs.outputs.length} outputs from database (total: ${outputs.totalOutputs})`
+  //     )
+  //     if (outputs.outputs.length > 0) {
+  //       console.log(`   First output: ${outputs.outputs[0].satoshis} sats`)
+  //     }
+
+  //     expect(outputs).toBeDefined()
+  //     expect(outputs.outputs).toBeDefined()
+  //     expect(Array.isArray(outputs.outputs)).toBe(true)
+  //     expect(typeof outputs.totalOutputs).toBe('number')
+  //     expect(outputs.totalOutputs).toBeGreaterThanOrEqual(0)
+  //   }, 10000)
+
+  //   test('relinquishOutput - should relinquish an output from wallet tracking', async () => {
+  //     console.log('🗑️  Testing output relinquishment...')
+  //     // Use a dummy outpoint since we likely don't have real outputs to relinquish
+  //     const dummyOutpoint =
+  //       '0000000000000000000000000000000000000000000000000000000000000000:0'
+
+  //     try {
+  //       const result = await setup.wallet.relinquishOutput({
+  //         basket: 'default',
+  //         output: dummyOutpoint
+  //       })
+
+  //       console.log('✅ Output relinquished successfully')
+  //       expect(result).toBeDefined()
+  //       expect(result.relinquished).toBeDefined()
+  //     } catch (err: any) {
+  //       console.log(
+  //         '⚠️  Output relinquishment failed (expected with dummy outpoint)'
+  //       )
+  //       // Expected to fail with dummy outpoint
+  //       expect(err).toBeDefined()
+  //     }
+  //     console.log('✅ Output relinquishment test completed')
+  //   }, 10000)
+  // })
+
+  // ============================================================================
+  // Certificates
+  // ============================================================================
+
+  // describe('Certificates', () => {
+  //   test('acquireCertificate - should attempt to acquire a certificate', async () => {
+  //     console.log('📜 Testing certificate acquisition...')
+  //     console.log('⚠️  NOTE: certifierUrl uses port 9999 (not 8000) - this is CORRECT ARCHITECTURE.')
+  //     console.log('   Storage and certification are separate services with separate URLs.')
+  //     console.log('   This matches Go/TypeScript implementations and production deployments.')
+  //     try {
+  //       const result = await setup.wallet.acquireCertificate({
+  //         type: Buffer.from('test-certificate').toString('base64'),
+  //         certifier: setup.identityKey,
+  //         acquisitionProtocol: 'issuance',
+  //         // ARCHITECTURE: Certifier and storage MUST be separate services
+  //         // Each creates independent BRC-104 authentication sessions
+  //         // This matches production deployment patterns across all SDK implementations
+  //         certifierUrl: 'http://localhost:9999',
+  //         fields: {
+  //           name: 'Test User',
+  //           email: 'test@example.com'
+  //         },
+  //         privilegedReason: 'Demo acquisition'
+  //       })
+  //       console.log('📜 Certificate acquired successfully')
+  //       expect(result).toBeDefined()
+  //     } catch (err: any) {
+  //       console.log(
+  //         '⚠️  Certificate acquisition failed (expected - no certifier service running)'
+  //       )
+  //       // Expected to fail - there's no real certifier service
+  //       expect(err).toBeDefined()
+  //     }
+  //     console.log('✅ Certificate acquisition test completed')
+  //   }, 10000)
+
+  //   test('listCertificates - should list wallet certificates', async () => {
+  //     const certs = await setup.wallet.listCertificates({
+  //       certifiers: [],
+  //       types: [],
+  //       limit: 10,
+  //       offset: 0
+  //     })
+
+  //     console.log(
+  //       `📜 Listed ${certs.certificates.length} certificates from database`
+  //     )
+  //     if (certs.certificates.length > 0) {
+  //       console.log(
+  //         `   Certificate types: ${certs.certificates.map(c => c.type).join(', ')}`
+  //       )
+  //     }
+
+  //     expect(certs).toBeDefined()
+  //     expect(certs.certificates).toBeDefined()
+  //     expect(Array.isArray(certs.certificates)).toBe(true)
+  //     expect(certs.certificates.length).toBeGreaterThanOrEqual(0)
+  //     if (certs.certificates.length > 0) {
+  //       const testCert = certs.certificates.find(
+  //         c => c.type === 'test-certificate'
+  //       )
+  //       if (testCert) {
+  //         expect(testCert.subject).toBeDefined()
+  //       }
+  //     }
+  //   }, 10000)
+
+  //   test('relinquishCertificate - should relinquish a certificate', async () => {
+  //     console.log('🗑️  Testing certificate relinquishment...')
+  //     // First check if we have any certificates to relinquish
+  //     const certs = await setup.wallet.listCertificates({
+  //       certifiers: [],
+  //       types: [],
+  //       limit: 10,
+  //       offset: 0
+  //     })
+
+  //     console.log(
+  //       `📜 Found ${certs.certificates.length} certificates to potentially relinquish`
+  //     )
+  //     if (certs.certificates.length === 0) {
+  //       console.log('⚠️  No certificates to relinquish, skipping test')
+  //       return
+  //     }
+
+  //     // Try to relinquish the first certificate
+  //     const cert = certs.certificates[0]
+  //     console.log(`🗑️  Attempting to relinquish certificate: ${cert.type}`)
+
+  //     try {
+  //       await setup.wallet.relinquishCertificate({
+  //         type: cert.type,
+  //         certifier: cert.certifier || 'self',
+  //         serialNumber: cert.serialNumber || ''
+  //       })
+  //       console.log('✅ Certificate relinquished successfully')
+  //     } catch (err: any) {
+  //       console.log(
+  //         '⚠️  Certificate relinquishment failed (expected in test environment)'
+  //       )
+  //       // Expected to fail in test environment
+  //       expect(err).toBeDefined()
+  //     }
+  //     console.log('✅ Certificate relinquishment test completed')
+  //   }, 10000)
+  // })
+
+  // ============================================================================
+  // Identity Discovery
+  // ============================================================================
+
+  // describe('Identity Discovery', () => {
+  //   test('discoverByIdentityKey - should discover certificates by identity key', async () => {
+  //     console.log('🔍 Testing identity discovery by identity key...')
+  //     try {
+  //       const result = await setup.wallet.discoverByIdentityKey({
+  //         identityKey: setup.identityKey,
+  //         limit: 10,
+  //         offset: 0,
+  //         seekPermission: true
+  //       })
+
+  //       console.log(
+  //         `🔍 Found ${result.certificates.length} certificates by identity key`
+  //       )
+  //       expect(result).toBeDefined()
+  //       expect(result.certificates).toBeDefined()
+  //       expect(Array.isArray(result.certificates)).toBe(true)
+  //       console.log('✅ Identity discovery by identity key completed')
+  //     } catch (err: any) {
+  //       console.log(
+  //         '⚠️  Identity discovery by identity key failed (expected in local test environment)'
+  //       )
+  //       // Expected to fail in test environment
+  //       expect(err).toBeDefined()
+  //     }
+  //   }, 10000)
+
+  //   test('discoverByAttributes - should discover certificates by attributes', async () => {
+  //     console.log('🔍 Testing identity discovery by attributes...')
+  //     try {
+  //       const result = await setup.wallet.discoverByAttributes({
+  //         attributes: { verified: 'true' },
+  //         limit: 10,
+  //         offset: 0
+  //       })
+
+  //       console.log(
+  //         `🔍 Found ${result.certificates.length} certificates by attributes`
+  //       )
+  //       expect(result).toBeDefined()
+  //       expect(result.certificates).toBeDefined()
+  //       expect(Array.isArray(result.certificates)).toBe(true)
+  //       console.log('✅ Identity discovery by attributes completed')
+  //     } catch (err: any) {
+  //       console.log(
+  //         '⚠️  Identity discovery by attributes failed (expected in local test environment)'
+  //       )
+  //       // Expected to fail in test environment
+  //       expect(err).toBeDefined()
+  //     }
+  //   }, 10000)
+  // })
+
+  // // ============================================================================
+  // // Transactions
+  // // ============================================================================
+
+  // describe('Transactions', () => {
+  //   test('internalizeAction - should internalize an external transaction', async () => {
+  //     console.log('📥 Testing transaction internalization...')
+  //     // This is a complex operation that requires an actual external transaction
+  //     // For testing purposes, we'll try with minimal parameters and expect graceful failure
+  //     try {
+  //       const dummyTxHex =
+  //         '01000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0100ffffffff01000000000000000000000000'
+  //       const result = await setup.wallet.internalizeAction({
+  //         tx: Array.from(Buffer.from(dummyTxHex, 'hex')),
+  //         outputs: [
+  //           {
+  //             outputIndex: 0,
+  //             protocol: 'basket insertion',
+  //             insertionRemittance: {
+  //               basket: 'default'
+  //             }
+  //           }
+  //         ],
+  //         description: 'Test internalization of external transaction'
+  //       })
+
+  //       console.log('✅ Transaction internalized successfully')
+  //       expect(result).toBeDefined()
+  //     } catch (err: any) {
+  //       console.log(
+  //         '⚠️  Transaction internalization failed (expected with dummy data)'
+  //       )
+  //       // Expected to fail with dummy data
+  //       expect(err).toBeDefined()
+  //     }
+  //     console.log('✅ Transaction internalization test completed')
+  //   }, 10000)
+  // })
+
+  // // ============================================================================
+  // // Blockchain Info
+  // // ============================================================================
+
+  // describe.skip('Blockchain Info', () => {
+  //   test('getHeight - should fetch current block height', async () => {
+  //     // Skipped for Python storage server tests - requires external blockchain API
+  //   }, 10000)
+
+  //   test('getHeaderForHeight - should fetch header for specific height', async () => {
+  //     // Skipped for Python storage server tests - requires external blockchain API
+  //   }, 10000)
+  // })
+})
diff --git a/src/brc100.py.test.ts b/src/brc100.py.test.ts
new file mode 100644
index 0000000..1a0bda3
--- /dev/null
+++ b/src/brc100.py.test.ts
@@ -0,0 +1,1169 @@
+import { PrivateKey, Transaction, MerklePath, P2PKH, Beef, PublicKey, BEEF_V2 } from '@bsv/sdk'
+import { Setup, SetupWallet, StorageClient, Services, Chain } from '@bsv/wallet-toolbox'
+import { exit } from 'process'
+
+/**
+ * Default py-wallet-toolbox endpoint URL.
+ */
+const DEFAULT_PY_WALLET_TOOLBOX_URL = 'http://localhost:8000'
+
+/**
+ * Build Atomic BEEF from raw transaction hex.
+ *
+ * This helper function takes a raw transaction hex and:
+ * 1. Parses the transaction to get txid
+ * 2. Attempts to fetch merkle proof from Services (if mined)
+ * 3. Builds Atomic BEEF format
+ *
+ * @param rawTxHex Raw transaction hex string
+ * @param chain Network chain ('main' or 'test')
+ * @returns Atomic BEEF binary data and txid
+ */
+async function buildAtomicBeefFromRawTx(
+  rawTxHex: string,
+  chain: Chain
+): Promise<{
+  atomicBeef: number[]
+  txid: string
+}> {
+  // console.log(`🔍 Parsing raw transaction (${rawTxHex.length} chars)...`)
+
+  // Parse the raw transaction to get txid
+  const tx = Transaction.fromHex(rawTxHex)
+  const txid = tx.id('hex')
+
+  // console.log(`✅ Transaction parsed`)
+  // console.log(`   TXID: ${txid}`)
+  //console.log(`   Inputs: ${tx.inputs.length}, Outputs: ${tx.outputs.length}`)
+
+  // Use Services.getBeefForTxid() to build a valid BEEF
+  // This method handles all the complexity of fetching parent transactions
+  // and merkle proofs recursively to build a valid BEEF
+  // console.log(`🔍 Building BEEF using Services.getBeefForTxid()...`)
+  const services = new Services(chain)
+
+  try {
+    const beef = await services.getBeefForTxid(txid)
+
+    // console.log(`✅ BEEF built successfully`)
+    // console.log(`   ${beef.toLogString()}`)
+
+    // Convert to Atomic BEEF binary format
+    const atomicBeef = beef.toBinaryAtomic(txid)
+    // console.log(`   Size: ${atomicBeef.length} bytes`)
+
+    return { atomicBeef, txid }
+  } catch (error: any) {
+    // console.log(`⚠️  Failed to build BEEF using Services.getBeefForTxid(): ${error.message}`)
+    // console.log(`   Falling back to manual BEEF building...`)
+
+    // Fallback: Build a simple BEEF with just the transaction
+    // This may fail validation if the transaction is unconfirmed
+    const beef = new Beef(BEEF_V2)
+
+    // Try to get merkle proof for the main transaction
+    try {
+      const merkleResult = await services.getMerklePath(txid)
+      if (merkleResult && merkleResult.merklePath) {
+        tx.merklePath = merkleResult.merklePath
+        // console.log(`✅ Merkle proof found (height: ${merkleResult.merklePath.blockHeight})`)
+      }
+    } catch (error: any) {
+      // console.log(`⚠️  No merkle proof found - transaction may be unconfirmed`)
+    }
+
+    beef.mergeTransaction(tx)
+    const atomicBeef = beef.toBinaryAtomic(txid)
+
+    // console.log(`⚠️  Built fallback BEEF (may not be valid)`)
+    // console.log(`   BEEF contains ${beef.txs.length} transactions and ${beef.bumps.length} BUMPS`)
+
+    return { atomicBeef, txid }
+  }
+}
+
+describe('BRC-100 Wallet Operations (Python Storage Server)', () => {
+  let setup: SetupWallet
+  let walletServiceAvailable = false
+
+  beforeAll(async () => {
+    const endpointUrl =
+      process.env.PY_WALLET_TOOLBOX_URL || DEFAULT_PY_WALLET_TOOLBOX_URL
+    const env = Setup.getEnv('test')
+    // console.log({env})
+    // Determine which key to use
+    let rootKeyHex: string = process.env.LIVE_PRIVATE_KEY || ''
+      
+    try {
+      // Create wallet without any storage providers
+      setup = await Setup.createWallet({
+        env,
+        rootKeyHex
+      })
+
+      // Reduced verbose logging
+
+      // Create a StorageClient connected to the py-wallet-toolbox storage server
+      const storageClient = new StorageClient(setup.wallet, endpointUrl)
+      await storageClient.makeAvailable()
+      await setup.storage.addWalletStorageProvider(storageClient)
+
+      // Try to connect to verify the service is available
+      await setup.wallet.waitForAuthentication({})
+      walletServiceAvailable = true
+      // console.log({wallet: setup.wallet})
+    } catch (error: any) {
+      walletServiceAvailable = false
+      const errorMessage = error?.message || String(error)
+
+      if (
+        errorMessage.includes('fetch failed') ||
+        errorMessage.includes('ECONNREFUSED') ||
+        errorMessage.includes('Network error')
+      ) {
+        console.error(
+          '\n' +
+          '='.repeat(80) +
+          '\n' +
+          '⚠️  PY WALLET TOOLBOX STORAGE SERVER NOT AVAILABLE\n' +
+          '='.repeat(80) +
+          '\n' +
+          `\nThe py-wallet-toolbox storage server is not running at ${endpointUrl}\n` +
+          '\nTo run these tests, you need to start the py-wallet-toolbox storage server.\n' +
+          '\nSetup steps:\n' +
+          '  1. Navigate to the py-wallet-toolbox directory:\n' +
+          '     cd ../py-wallet-toolbox/examples/storage_server_example\n' +
+          '  2. Activate the virtual environment:\n' +
+          '     source venv/bin/activate  # Linux/Mac\n' +
+          '     # or\n' +
+          '     venv\\Scripts\\activate     # Windows\n' +
+          '  3. Install dependencies:\n' +
+          '     pip install -r requirements.txt\n' +
+          '  4. Run migrations:\n' +
+          '     python manage.py migrate\n' +
+          '  5. Start the storage server:\n' +
+          '     python manage.py runserver\n' +
+          '\nThe server should be available at http://localhost:8000\n' +
+          '\nFor more details, see the py-wallet-toolbox storage server README.md\n' +
+          '\n' +
+          '='.repeat(80) +
+          '\n'
+        )
+
+        // Exit early to prevent running all tests
+        process.exit(1)
+      }
+
+      // Re-throw other errors
+      throw error
+    }
+  }, 10000)
+
+  // ============================================================================
+  //   Basics
+  // ============================================================================
+
+  describe('Basics', () => {
+    test('walletInfo - should retrieve wallet address and balance', async () => {
+      // Test balance retrieval
+      let balance = 0
+      try {
+        balance = await setup.wallet.balance()
+        console.log('💰 Balance:', balance)
+        expect(typeof balance).toBe('number')
+        expect(balance).toBeGreaterThanOrEqual(0)
+
+
+        if (balance === 0) {
+          // Try to internalize funding automatically in live mode
+          try {
+            const FAUCET_DERIVATION_PREFIX = "faucet-prefix-01"
+            const FAUCET_DERIVATION_SUFFIX = "faucet-suffix-01"
+            const derivationPrefixB64 = Buffer.from(FAUCET_DERIVATION_PREFIX, 'utf-8').toString('base64')
+            const derivationSuffixB64 = Buffer.from(FAUCET_DERIVATION_SUFFIX, 'utf-8').toString('base64')
+            // Use base64 strings in keyID to match validation behavior (Go/TS use base64 strings directly)
+            const keyID = `${derivationPrefixB64} ${derivationSuffixB64}`
+
+            // Use AnyoneKey as sender (matches Python example)
+            // AnyoneKey = PrivateKey(1).public_key()
+            // PrivateKey(1) in hex is 32 bytes with value 1: '0000000000000000000000000000000000000000000000000000000000000001'
+            const anyoneKeyPriv = PrivateKey.fromString('0000000000000000000000000000000000000000000000000000000000000001')
+            const anyoneKey = anyoneKeyPriv.toPublicKey()
+            const anyoneKeyHex = anyoneKey.toString()
+
+            // Request derived public key using BRC-29 protocol (wallet payment protocol)
+            // Use AnyoneKey as counterparty (external sender, like a faucet)
+            // NOTE: keyID uses base64 strings to match validation behavior (Go/TS use base64 strings directly)
+            // NOTE: forSelf=true to match AddressForSelf direction (recipient derives for self)
+            // This matches validation which uses derivePrivateKey (recipient's perspective)
+            const derivedKeyResult = await setup.wallet.getPublicKey({
+              protocolID: [2, '3241645161d8'], // BRC-29 wallet payment protocol
+              keyID: keyID, // Base64 strings (matches Go/TS validation)
+              counterparty: anyoneKeyHex, // Use AnyoneKey for external sender (faucet)
+              forSelf: true // CRITICAL: Must be true to match AddressForSelf direction
+            })
+
+            if (!derivedKeyResult.publicKey) {
+              throw new Error('Failed to get derived public key from wallet')
+            }
+
+            // Create P2PKH address from derived public key
+            const derivedPublicKey = PublicKey.fromString(derivedKeyResult.publicKey)
+            const network = setup.chain === 'main' ? 'mainnet' : 'testnet'
+            const fundingAddress = derivedPublicKey.toAddress(network)
+            // console.log('📬 EXTERNAL FUNDING ADDRESS (P2PKH)')
+            console.log('Address:', fundingAddress)
+
+            // Check if the funding address has funds via Whatsonchain API
+            const wocNetwork = setup.chain === 'main' ? 'main' : 'test'
+            const wocBaseUrl = `https://api.whatsonchain.com/v1/bsv/${wocNetwork}`
+
+            try {
+              // Check for unspent outputs at this address
+              const unspentResponse = await fetch(`${wocBaseUrl}/address/${fundingAddress}/unspent`)
+              if (!unspentResponse.ok) {
+                throw new Error(`Whatsonchain API error: ${unspentResponse.statusText}`)
+              }
+
+              const unspentData = await unspentResponse.json()
+              // console.log(`📊 Found ${unspentData.length} unspent output(s) at funding address`)
+
+              if (unspentData.length > 0) {
+                // Get the first unspent output (or we could process all of them)
+                const firstUtxo = unspentData[0]
+                const txid = firstUtxo.tx_hash
+                const outputIndex = firstUtxo.tx_pos
+
+                // console.log(`📥 Found funding transaction: ${txid}:${outputIndex}`)
+                // console.log(`💰 Amount: ${firstUtxo.value} satoshis`)
+
+                // Show Whatsonchain link for the funding transaction
+                const wocNetwork = setup.chain === 'main' ? '' : 'test.'
+                const fundingTxUrl = `https://${wocNetwork}whatsonchain.com/tx/${txid}`
+                // console.log(`🔗 View funding transaction on Whatsonchain: ${fundingTxUrl}`)
+
+                // Get the raw transaction hex
+                const txResponse = await fetch(`${wocBaseUrl}/tx/${txid}/hex`)
+                if (!txResponse.ok) {
+                  throw new Error(`Failed to fetch transaction: ${txResponse.statusText}`)
+                }
+
+                const txHex = await txResponse.text()
+                // console.log(`📄 Retrieved raw transaction (${txHex.length / 2} bytes)`)
+                // TODO: replace things below with buildAtomicBeefFromRawTx
+                // Parse the transaction to verify the output
+                const txBytes = Array.from(Buffer.from(txHex, 'hex'))
+                const tx = Transaction.fromBinary(txBytes)
+
+                // Verify the output at the specified index pays to our address
+                if (outputIndex >= tx.outputs.length) {
+                  throw new Error(`Output index ${outputIndex} out of range (${tx.outputs.length} outputs)`)
+                }
+
+                const output = tx.outputs[outputIndex]
+                // Verify the output pays to our address by comparing locking scripts
+                const expectedLockingScript = new P2PKH().lock(fundingAddress)
+                const actualLockingScript = output.lockingScript.toHex()
+                const expectedLockingScriptHex = expectedLockingScript.toHex()
+
+                // console.log(`   Output ${outputIndex} locking script: ${actualLockingScript}`)
+                // console.log(`   Expected locking script: ${expectedLockingScriptHex}`)
+
+                if (actualLockingScript !== expectedLockingScriptHex) {
+                  console.log(`⚠️  Warning: Output ${outputIndex} locking script does not match funding address`)
+                  console.log(`   This output may not be a BRC-29 wallet payment - it might be a regular P2PKH`)
+                  // Continue anyway - might be a different output format
+                } else {
+                  // console.log(`✅ Output ${outputIndex} locking script matches funding address`)
+                }
+
+                // Build Atomic BEEF using the helper function
+                const { atomicBeef } = await buildAtomicBeefFromRawTx(txHex, setup.chain)
+
+                try {
+                  // Prepare payment remittance with proper base64 encoding
+                  // Match Python example: use AnyoneKey as senderIdentityKey (external sender/faucet)
+                  // NOTE: derivationPrefix and derivationSuffix are already base64-encoded above
+                  const paymentRemittance = {
+                    derivationPrefix: derivationPrefixB64, // Already base64-encoded
+                    derivationSuffix: derivationSuffixB64, // Already base64-encoded
+                    senderIdentityKey: anyoneKeyHex // Use AnyoneKey (external sender, like faucet)
+                  }
+
+
+                  // Internalize as "wallet payment" protocol (matches Python example)
+                  // Python example always uses "wallet payment" protocol with paymentRemittance
+                  const internalizeResult = await setup.wallet.internalizeAction({
+                    tx: atomicBeef,
+                    outputs: [
+                      {
+                        outputIndex: outputIndex,
+                        protocol: 'wallet payment',
+                        paymentRemittance: paymentRemittance
+                      }
+                    ],
+                    description: 'Auto-internalize funding transaction'
+                  })
+
+                  if (internalizeResult) {
+                    // Show Whatsonchain link
+                    const wocNetwork = setup.chain === 'main' ? '' : 'test.'
+                    const fundingTxUrl = `https://${wocNetwork}whatsonchain.com/tx/${txid}`
+                    console.log(`🔗 View funding transaction on Whatsonchain: ${fundingTxUrl}`)
+
+                    await new Promise(resolve => setTimeout(resolve, 2000))
+                    console.log('Slept for 2 seconds after tx')
+                  }
+                } catch (internalizeErr: any) {
+                  // Final fallback - log and continue
+                  console.log('⚠️  Could not internalize transaction:', internalizeErr.message)
+                  process.exit(-1)
+                }
+              } else {
+                console.log('ℹ️  No unspent outputs found at funding address: '+fundingAddress)
+                exit(-1)
+              }
+            } catch (apiErr: any) {
+              console.log('   Could not check external API:', apiErr.message)
+              // Don't throw - this is best-effort automatic funding
+              process.exit(-1)
+            }
+          } catch (apiErr) {
+            console.log('   Could not check external API')
+            process.exit(-1)
+          }
+        }
+      } catch (err: any) {
+        console.log('⚠️  Balance check failed (expected for local testing)')
+        // Balance might fail if services not configured, but that's expected
+        process.exit(-1)
+      }
+      // Test completed
+    }, 10000)
+
+    test('waitForAuthentication - should resolve immediately for base wallet', async () => {
+      // console.log('🔐 Testing waitForAuthentication...')
+      const result = await setup.wallet.waitForAuthentication({})
+      // console.log(`🔐 Authentication result: ${JSON.stringify(result)}`)
+      expect(result).toBeDefined()
+      expect(result.authenticated).toBeDefined()
+      // Base wallet resolves immediately
+      // console.log('✅ waitForAuthentication test completed')
+    }, 10000)
+
+    test('isAuthenticated - should check if wallet is authenticated', async () => {
+      // console.log('🔐 Testing isAuthenticated...')
+      const result = await setup.wallet.isAuthenticated({})
+      // console.log(`🔐 Authentication check result: ${JSON.stringify(result)}`)
+      expect(result).toBeDefined()
+      expect(result.authenticated).toBeDefined()
+      expect(typeof result.authenticated).toBe('boolean')
+      // console.log('✅ isAuthenticated test completed')
+    }, 10000)
+
+    test('getNetwork - should return the network information', async () => {
+      // console.log('🌐 Testing getNetwork...')
+      const result = await setup.wallet.getNetwork({})
+      // console.log(`🌐 Network info: ${JSON.stringify(result)}`)
+      expect(result).toBeDefined()
+      expect(result.network).toBeDefined()
+      expect(['main', 'test', 'testnet']).toContain(result.network)
+      // console.log('✅ getNetwork test completed')
+    }, 10000)
+
+    test('getVersion - should return wallet version information', async () => {
+      // console.log('📦 Testing getVersion...')
+      const result = await setup.wallet.getVersion({})
+      // console.log(`📦 Version info: ${JSON.stringify(result)}`)
+      expect(result).toBeDefined()
+      expect(result.version).toBeDefined()
+      expect(typeof result.version).toBe('string')
+      // console.log('✅ getVersion test completed')
+    }, 10000)
+  })
+
+  // ============================================================================
+  // Keys and Signatures
+  // ============================================================================
+
+  describe('Keys and Signatures', () => {
+    test('getPublicKey - should derive protocol-specific public key', async () => {
+      // console.log('🔑 Testing public key derivation...')
+      const result = await setup.wallet.getPublicKey({
+        identityKey: true,
+        protocolID: [0, 'testprotocol'],
+        keyID: '1',
+        counterparty: 'self'
+      })
+
+      // console.log(
+      //   `🔑 Derived public key: ${result.publicKey.substring(0, 20)}...`
+      // )
+      expect(result).toBeDefined()
+      expect(result.publicKey).toBeDefined()
+      expect(typeof result.publicKey).toBe('string')
+      expect(result.publicKey.length).toBeGreaterThan(60) // Public key length
+      // console.log('✅ Public key test completed')
+    }, 10000)
+
+    test('createSignature - should sign data with wallet keys', async () => {
+      // console.log('✍️  Testing signature creation...')
+      const testMessage = 'Hello, BSV!'
+      const data = Array.from(Buffer.from(testMessage))
+
+      const result = await setup.wallet.createSignature({
+        data,
+        protocolID: [0, 'testprotocol'],
+        keyID: '1',
+        counterparty: 'self'
+      })
+      // console.log(
+      //   `✍️  Created signature: ${Buffer.from(result.signature.slice(0, 10)).toString('hex')}...`
+      // )
+      expect(result).toBeDefined()
+      expect(result.signature).toBeDefined()
+      // console.log('✅ Signature creation test completed')
+    }, 10000)
+
+    test('verifySignature - should create and verify signature round-trip', async () => {
+      // console.log('🔍 Testing signature verification...')
+      const testMessage = 'Test signature verification'
+      const data = Array.from(Buffer.from(testMessage))
+
+      // Create signature
+      const createResult = await setup.wallet.createSignature({
+        data,
+        protocolID: [0, 'testprotocol'],
+        keyID: '1',
+        counterparty: 'self'
+      })
+
+      // Verify signature
+      const verifyResult = await setup.wallet.verifySignature({
+        data,
+        signature: createResult.signature,
+        protocolID: [0, 'testprotocol'],
+        keyID: '1',
+        counterparty: 'self'
+      })
+
+      // console.log(`🔍 Signature verification result: ${verifyResult.valid}`)
+      expect(verifyResult).toBeDefined()
+      expect(verifyResult.valid).toBe(true)
+      // console.log('✅ Signature verification test completed')
+    }, 10000)
+
+    test('revealCounterpartyKeyLinkage - should reveal counterparty key linkage', async () => {
+      try {
+        const result = await setup.wallet.revealCounterpartyKeyLinkage({
+          counterparty: 'self',
+          verifier: '02' + 'a'.repeat(64), // demo verifier pubkey
+          privilegedReason: 'Demo'
+        })
+
+        expect(result).toBeDefined()
+        expect(result.prover).toBeDefined()
+        expect(result.counterparty).toBeDefined()
+      } catch (err: any) {
+        // This might fail in test environments, which is expected
+      }
+    }, 10000)
+
+    test('revealSpecificKeyLinkage - should reveal specific key linkage', async () => {
+      try {
+        const result = await setup.wallet.revealSpecificKeyLinkage({
+          counterparty: 'self',
+          verifier: '02' + 'a'.repeat(64), // demo verifier pubkey
+          protocolID: [0, 'testprotocol'],
+          keyID: '1',
+          privilegedReason: 'Demo'
+        })
+
+        expect(result).toBeDefined()
+        expect(result.prover).toBeDefined()
+        expect(result.counterparty).toBeDefined()
+        expect(result.protocolID).toBeDefined()
+        expect(result.keyID).toBeDefined()
+      } catch (err: any) {
+        // This might fail in test environments, which is expected
+      }
+    }, 10000)
+  })
+
+  // // ============================================================================
+  // // Crypto Operations
+  // // ============================================================================
+
+  describe('Crypto Operations', () => {
+    test('createHmac - should generate HMAC for message', async () => {
+      // console.log('🔐 Testing HMAC creation...')
+      const testMessage = 'Hello, HMAC!'
+      const data = Array.from(Buffer.from(testMessage))
+
+      const result = await setup.wallet.createHmac({
+        data,
+        protocolID: [0, 'testprotocol'],
+        keyID: '1',
+        counterparty: 'self'
+      })
+
+      // console.log(
+      //   `🔐 Generated HMAC: ${Buffer.from(result.hmac.slice(0, 10)).toString('hex')}...`
+      // )
+      expect(result).toBeDefined()
+      expect(result.hmac).toBeDefined()
+      // console.log('✅ HMAC creation test completed')
+    }, 10000)
+
+    test('verifyHmac - should create and verify HMAC round-trip', async () => {
+      // console.log('🔍 Testing HMAC verification...')
+      const testMessage = 'Test HMAC verification'
+      const data = Array.from(Buffer.from(testMessage))
+
+      // Create HMAC
+      const createResult = await setup.wallet.createHmac({
+        data,
+        protocolID: [0, 'testprotocol'],
+        keyID: '1',
+        counterparty: 'self'
+      })
+
+      // Verify HMAC
+      const verifyResult = await setup.wallet.verifyHmac({
+        data,
+        hmac: createResult.hmac,
+        protocolID: [0, 'testprotocol'],
+        keyID: '1',
+        counterparty: 'self'
+      })
+
+      // console.log(`🔍 HMAC verification result: ${verifyResult.valid}`)
+      // console.log('✅ HMAC verification test completed')
+      expect(verifyResult).toBeDefined()
+      expect(verifyResult.valid).toBe(true)
+      // console.log('✅ HMAC verification test completed')
+    }, 10000)
+
+    test('encrypt/decrypt - should encrypt data and decrypt it back', async () => {
+      // console.log('🔒 Testing encryption/decryption...')
+      const testMessage = 'Secret Message!'
+      const plaintext = Array.from(Buffer.from(testMessage))
+
+      // Encrypt
+      const encryptResult = await setup.wallet.encrypt({
+        plaintext,
+        protocolID: [0, 'encryption'],
+        keyID: '1',
+        counterparty: 'self'
+      })
+
+      // console.log(
+      //   `🔒 Encrypted message: ${Buffer.from(encryptResult.ciphertext.slice(0, 10)).toString('hex')}...`
+      // )
+      expect(encryptResult).toBeDefined()
+      expect(encryptResult.ciphertext).toBeDefined()
+
+      // Decrypt
+      const decryptResult = await setup.wallet.decrypt({
+        ciphertext: encryptResult.ciphertext,
+        protocolID: [0, 'encryption'],
+        keyID: '1',
+        counterparty: 'self'
+      })
+
+      expect(decryptResult).toBeDefined()
+      expect(decryptResult.plaintext).toBeDefined()
+      expect(Array.isArray(decryptResult.plaintext)).toBe(true)
+
+      // Verify decrypted message matches original
+      const decrypted = Buffer.from(decryptResult.plaintext).toString()
+      // console.log(`🔓 Decrypted message: "${decrypted}"`)
+      expect(decrypted).toBe(testMessage)
+      // console.log('✅ Encryption/decryption test completed')
+    }, 10000)
+  })
+
+  // ============================================================================
+  // Actions
+  // ============================================================================
+
+  describe('Actions', () => {
+    test('createAction - should create OP_RETURN transaction', async () => {
+      // Check balance first - need at least 10 sats to safely run this test
+      // For externally-funded outputs, also check the 'funding' basket
+      let balance = 0
+      try {
+        balance = await setup.wallet.balance()
+        // console.log({ balance })
+
+      } catch (err) {
+        console.log('⚠️  Could not check balance - assuming 0')
+      }
+
+      const requiredBalance = 1  // Temporarily lower for debugging
+      if (balance < requiredBalance) {
+          console.log('⚠️  Skipping test - insufficient balance')
+          return
+      }
+
+      console.log(`🔍 Wallet balance: ${balance}, proceeding with test`)
+
+      try {
+        const message = 'Hello, World! - Test Action'
+        const messageBytes = Buffer.from(message)
+        const hexData = messageBytes.toString('hex')
+        const length = messageBytes.length
+        const lockingScript = `006a${length.toString(16).padStart(2, '0')}${hexData}`
+
+        let action: any
+        try {
+          action = await setup.wallet.createAction({
+            description: `Test action: ${message}`,
+            outputs: [
+              { lockingScript, satoshis: 0, outputDescription: 'Test output', basket: 'opreturn', tags: ['test'] }
+            ],
+            labels: ['test:create_action'],
+            options: {
+              acceptDelayedBroadcast: false
+            }
+          })
+          // console.dir(action, { depth: null })
+          await new Promise(resolve => setTimeout(resolve, 2000))
+          console.log('Slept for 2 seconds after tx')
+        } catch (error: any) {
+          // When acceptDelayedBroadcast is false, unsuccessful results throw WERR_REVIEW_ACTIONS
+          // Extract the results from the error and treat as action result
+          if (error.name === 'WERR_REVIEW_ACTIONS' || error.message?.includes('require review')) {
+            console.log('⚠️  Action requires review even with delayed broadcast')
+            action = {
+              txid: error.txid,
+              tx: error.tx,
+              sendWithResults: error.sendWithResults || [],
+              reviewActionResults: error.reviewActionResults || [],
+            }
+            // console.dir(action, { depth: null })
+
+            // Log review results
+            if (action.reviewActionResults && action.reviewActionResults.length > 0) {
+              console.log(`📋 Found ${action.reviewActionResults.length} review action result(s)`)
+              // Log all review results for debugging
+              action.reviewActionResults.forEach((result: any, index: number) => {
+                console.log(`   Review result ${index + 1}:`, {
+                  status: result.status,
+                  txid: result.txid,
+                  reference: result.reference,
+                  message: result.message
+                })
+              })
+
+              // Debug: Check if we have tx data
+              if (action.tx) {
+                console.log(`📄 Transaction BEEF data length: ${action.tx.length} bytes`)
+                // Try to parse the BEEF to see what's in it
+                try {
+                  const beefData = action.tx
+                  console.log(`📄 First 100 bytes of BEEF: ${Buffer.from(beefData.slice(0, 100)).toString('hex')}`)
+                } catch (e: any) {
+                  console.log(`⚠️  Could not parse BEEF data: ${e.message}`)
+                }
+              } else {
+                console.log(`⚠️  No tx (BEEF) data in action`)
+              }
+
+              // Fail the test if any review action result has an error status
+              const errorResults = action.reviewActionResults.filter((result: any) => result.status === 'error')
+              if (errorResults.length > 0) {
+                const errorMessages = errorResults.map((result: any) =>
+                  `${result.txid || 'no-txid'}: ${result.message || 'Unknown error'}`
+                ).join('; ')
+                console.error(`❌ Review action failed with errors: ${errorMessages}`)
+                // Use expect().toBe() to fail the test explicitly
+                expect(errorResults.length).toBe(0)
+              }
+            }
+
+            // Also check sendWithResults for failures
+            if (action.sendWithResults && Array.isArray(action.sendWithResults)) {
+              const failedResults = action.sendWithResults.filter((result: any) => result.status === 'failed')
+              if (failedResults.length > 0) {
+                const errorMessages = failedResults.map((result: any) =>
+                  `${result.txid}: ${result.message || 'Broadcast failed'}`
+                ).join('; ')
+                console.error(`❌ Send action failed: ${errorMessages}`)
+                // Use expect().toBe() to fail the test explicitly
+                expect(failedResults.length).toBe(0)
+              }
+            }
+          } else {
+            // Some other error - log details and rethrow
+            console.error('❌ createAction failed with error:', error.name || error.constructor?.name)
+            console.error('   Message:', error.message)
+            if (error.stack) {
+              console.error('   Stack:', error.stack)
+            }
+            // Check for script evaluation errors
+            if (error.message && (error.message.includes('OP_EQUALVERIFY') || error.message.includes('Script evaluation'))) {
+              console.error('🔍 Script evaluation error detected - this usually means the unlocking script does not match the locking script')
+              console.error('   This can happen if:')
+              console.error('   1. The derivation fields (derivationPrefix/derivationSuffix) do not match the public key in the locking script')
+              console.error('   2. The counterparty type (SELF vs OTHER) is incorrect')
+              console.error('   3. The identity key used for derivation does not match')
+              console.error('   4. The output was internalized incorrectly (wrong protocol or missing derivation data)')
+            }
+            throw error
+          }
+        }
+        
+        // Also show links for sendWithResults if available
+        if (action.notDelayedResults && Array.isArray(action.notDelayedResults)) {
+          action.notDelayedResults.forEach((result: any) => {
+            if (result.txid && result.status === 'success') {
+              const chain = setup.wallet.chain || 'test'
+              const network = chain === 'main' ? '' : 'test.'
+              const whatsonchainUrl = `https://${network}whatsonchain.com/tx/${result.txid}`
+              console.log(`🔗 View transaction ${result.txid} on Whatsonchain: ${whatsonchainUrl}`)
+              // console.log(`   Status: ${result.status}`)
+            }
+
+            // Only fail the test if the transaction actually failed to broadcast
+            if (result.status === 'failed') {
+              throw new Error(`Transaction ${result.txid} failed with status ${result.status}`)
+            }
+          })
+        }
+//        console.log(`✅ Action created with ${action.signableTransaction ? 'signableTransaction' : action.txid ? 'txid' : 'unknown'}`)
+
+      } catch (err: any) {
+        // Don't swallow errors - if the transaction fails, the test should fail
+        throw err
+      }
+    }, 15000)
+    
+    test('createAction - verify action result structure', async () => {
+      // Check balance first
+      let balance = 0
+      try {
+        balance = await setup.wallet.balance()
+        // console.log(`💰 Current balance: ${balance} satoshis`)
+      } catch (err) {
+        console.log('⚠️  Could not check balance - assuming 0')
+      }
+
+      if (balance < 10) {
+        console.log('⚠️  Skipping structure test - insufficient balance')
+        return
+      }
+
+      try {
+        const message = 'Structure Test'
+        const messageBytes = Buffer.from(message)
+        const hexData = messageBytes.toString('hex')
+        const length = messageBytes.length
+        const lockingScript = `006a${length.toString(16).padStart(2, '0')}${hexData}`
+
+        let action
+        try {
+          action = await setup.wallet.createAction({
+            description: `Structure test: ${message}`,
+            outputs: [
+              {
+                lockingScript,
+                satoshis: 0,
+                outputDescription: 'Test output',
+                basket: 'opreturn',
+                tags: ['test']
+              }
+            ],
+            labels: ['test:structure'],
+            options: {
+              signAndProcess: false, 
+            }
+          })
+          
+          // console.dir(action, { depth: null })
+          // await new Promise(resolve => setTimeout(resolve, 2000))
+          // console.log('Slept for 2 seconds after tx')
+
+        } catch (err: any) {
+          console.error('❌ createAction failed:', err.message)
+          throw err
+        }
+
+        // console.log(
+        //   `✅ Structure test action created with ${action.signableTransaction ? 'signableTransaction' : action.txid ? 'txid' : 'unknown'}`
+        // )
+        expect(action).toBeDefined()
+        // Verify result structure - align with TypeScript behavior:
+        // When noSend: true and transaction is signed, expect txid (not signableTransaction)
+        // When signAndProcess: false, expect signableTransaction (not txid)
+        if (action.txid) {
+          // Transaction was signed - expect txid and tx, but NOT signableTransaction (TypeScript behavior)
+          expect(typeof action.txid).toBe('string')
+          expect(action.txid!.length).toBe(64)
+          expect(action.tx).toBeDefined()
+          expect(action.signableTransaction).toBeUndefined()
+        } else if (action.signableTransaction) {
+          // Transaction was not signed - expect signableTransaction (not txid)
+          expect(action.signableTransaction.reference).toBeDefined()
+          expect(action.signableTransaction.tx).toBeDefined()
+          // Cleanup - abort to release UTXOs (unreserve satoshis)
+          const reference = action.signableTransaction.reference
+          console.log(`🔄 Aborting action with reference: ${reference}`)
+          const abortResult = await setup.wallet.abortAction({
+            reference: reference
+          })
+          console.log(`✅ Abort action result:`, JSON.stringify(abortResult))
+          expect(abortResult).toBe(true)
+        } else {
+          throw new Error('Expected either signableTransaction or txid')
+        }
+      } catch (err: any) {
+        if (
+          err.message.includes('Insufficient funds') ||
+          err.message.includes('insufficient')
+        )
+          return
+        throw err
+      }
+    }, 15000)
+
+    test('listActions - should list recent wallet actions', async () => {
+      const actions = await setup.wallet.listActions({
+        labels: [],
+        limit: 10,
+        includeLabels: true
+      })
+
+      expect(actions).toBeDefined()
+      expect(actions.actions).toBeDefined()
+      expect(Array.isArray(actions.actions)).toBe(true)
+      expect(actions.actions.length).toBeGreaterThanOrEqual(0)
+    }, 10000)
+
+    test('signAction - should sign a previously created signable transaction', async () => {
+      // Check balance first
+      let balance = 0
+      try {
+        balance = await setup.wallet.balance()
+      } catch (err) {
+        console.log('⚠️  Could not check balance - assuming 0')
+      }
+
+      if (balance < 10) {
+        console.log('⚠️  Skipping signAction test - insufficient balance')
+        return
+      }
+
+      try {
+        // Step 1: Create an action with signAndProcess=false to get a signableTransaction
+        const signableResult = await setup.wallet.createAction({
+          description: 'Test for signAction - signable transaction',
+          outputs: [
+            {
+              lockingScript: '006a0b7369676e5f616374696f6e', // OP_RETURN "sign_action"
+              satoshis: 0,
+              outputDescription: 'Test output for signAction',
+              basket: 'opreturn'
+            }
+          ],
+          options: {
+            signAndProcess: false // This returns a signableTransaction
+          }
+        })
+
+        if (signableResult && signableResult.signableTransaction) {
+          const reference = signableResult.signableTransaction.reference
+
+          if (reference) {
+            // Step 2: Call signAction with the reference
+            // For wallet inputs, spends can be empty (wallet auto-signs)
+            const signResult = await setup.wallet.signAction({
+              reference: reference,
+              spends: {}, // Wallet inputs are auto-signed
+              options: { acceptDelayedBroadcast: true }
+            })
+
+            expect(signResult).toBeDefined()
+            // signAction returns either txid (if broadcasted) or tx (AtomicBEEF)
+            if (signResult.txid) {
+              expect(typeof signResult.txid).toBe('string')
+              expect(signResult.txid.length).toBe(64)
+            } else if (signResult.tx) {
+              expect(Array.isArray(signResult.tx)).toBe(true)
+              expect(signResult.tx.length).toBeGreaterThan(0)
+            } else {
+              // signAction may have completed but not returned txid/tx in some cases
+              // This is acceptable - the action was signed
+              expect(signResult).toBeDefined()
+            }
+          } else {
+            console.log('⚠️  signAction test: signableTransaction has no reference')
+          }
+        } else {
+          console.log('⚠️  signAction test: createAction with signAndProcess=false did not return signableTransaction')
+        }
+      } catch (err: any) {
+        if (
+          err.message.includes('Insufficient funds') ||
+          err.message.includes('insufficient')
+        ) {
+          return
+        }
+        // Log but don't fail - signAction may not be available in all scenarios
+        console.log(`⚠️  signAction test: ${err.message}`)
+      }
+    }, 15000)
+
+    test('abortAction - should abort an unsigned action if available', async () => {
+      // Check if there are any unsigned actions we can abort
+      const actions = await setup.wallet.listActions({ labels: [], limit: 20 })
+      const unsignedAction = actions.actions.find(
+        a => a.status === 'unsigned'
+      )
+
+      // listActions doesn't return references, so we can only abort
+      // actions we created in the same session with signableTransaction
+      expect(unsignedAction === undefined || unsignedAction.status).toBeTruthy()
+    }, 10000)
+  })
+
+  // ============================================================================
+  // Outputs
+  // ============================================================================
+
+  describe('Outputs', () => {
+    test('listOutputs - should list wallet outputs', async () => {
+      const outputs = await setup.wallet.listOutputs({
+        basket: 'default',
+        limit: 10,
+        offset: 0
+      })
+
+      expect(outputs).toBeDefined()
+      expect(outputs.outputs).toBeDefined()
+      expect(Array.isArray(outputs.outputs)).toBe(true)
+      expect(typeof outputs.totalOutputs).toBe('number')
+      expect(outputs.totalOutputs).toBeGreaterThanOrEqual(0)
+    }, 10000)
+
+    test('relinquishOutput - should relinquish an output from wallet tracking', async () => {
+      // Use a dummy outpoint since we likely don't have real outputs to relinquish
+      const dummyOutpoint =
+        '0000000000000000000000000000000000000000000000000000000000000000:0'
+
+      try {
+        const result = await setup.wallet.relinquishOutput({
+          basket: 'default',
+          output: dummyOutpoint
+        })
+
+        expect(result).toBeDefined()
+        expect(result.relinquished).toBeDefined()
+      } catch (err: any) {
+        // Expected to fail with dummy outpoint
+        expect(err).toBeDefined()
+      }
+    }, 10000)
+  })
+
+  // ============================================================================
+  // Certificates
+  // ============================================================================
+
+  describe('Certificates', () => {
+    test('acquireCertificate - should attempt to acquire a certificate', async () => {
+      try {
+        const result = await setup.wallet.acquireCertificate({
+          type: Buffer.from('test-certificate').toString('base64'),
+          certifier: setup.identityKey,
+          acquisitionProtocol: 'issuance',
+          certifierUrl: 'http://localhost:9999',
+          fields: {
+            name: 'Test User',
+            email: 'test@example.com'
+          },
+          privilegedReason: 'Demo acquisition'
+        })
+        expect(result).toBeDefined()
+      } catch (err: any) {
+        // Expected to fail - there's no real certifier service running
+        expect(err).toBeDefined()
+      }
+    }, 10000)
+
+    test('listCertificates - should list wallet certificates', async () => {
+      const certs = await setup.wallet.listCertificates({
+        certifiers: [],
+        types: [],
+        limit: 10,
+        offset: 0
+      })
+
+      expect(certs).toBeDefined()
+      expect(certs.certificates).toBeDefined()
+      expect(Array.isArray(certs.certificates)).toBe(true)
+      expect(certs.certificates.length).toBeGreaterThanOrEqual(0)
+      if (certs.certificates.length > 0) {
+        const testCert = certs.certificates.find(
+          c => c.type === 'test-certificate'
+        )
+        if (testCert) {
+          expect(testCert.subject).toBeDefined()
+        }
+      }
+    }, 10000)
+
+    test('relinquishCertificate - should relinquish a certificate', async () => {
+      // First check if we have any certificates to relinquish
+      const certs = await setup.wallet.listCertificates({
+        certifiers: [],
+        types: [],
+        limit: 10,
+        offset: 0
+      })
+
+      if (certs.certificates.length === 0) {
+        console.log('⚠️  No certificates to relinquish, skipping test')
+        return
+      }
+
+      // Try to relinquish the first certificate
+      const cert = certs.certificates[0]
+
+      try {
+        await setup.wallet.relinquishCertificate({
+          type: cert.type,
+          certifier: cert.certifier || 'self',
+          serialNumber: cert.serialNumber || ''
+        })
+      } catch (err: any) {
+        // Expected to fail in test environment
+        expect(err).toBeDefined()
+      }
+    }, 10000)
+  })
+
+  // ============================================================================
+  // Identity Discovery
+  // ============================================================================
+
+  describe('Identity Discovery', () => {
+    test('discoverByIdentityKey - should discover certificates by identity key', async () => {
+      try {
+        const result = await setup.wallet.discoverByIdentityKey({
+          identityKey: setup.identityKey,
+          limit: 10,
+          offset: 0,
+          seekPermission: true
+        })
+
+        expect(result).toBeDefined()
+        expect(result.certificates).toBeDefined()
+        expect(Array.isArray(result.certificates)).toBe(true)
+      } catch (err: any) {
+        // Expected to fail in test environment
+        expect(err).toBeDefined()
+      }
+    }, 10000)
+
+    test('discoverByAttributes - should discover certificates by attributes', async () => {
+      try {
+        const result = await setup.wallet.discoverByAttributes({
+          attributes: { verified: 'true' },
+          limit: 10,
+          offset: 0
+        })
+
+        expect(result).toBeDefined()
+        expect(result.certificates).toBeDefined()
+        expect(Array.isArray(result.certificates)).toBe(true)
+      } catch (err: any) {
+        // Expected to fail in test environment
+        expect(err).toBeDefined()
+      }
+    }, 10000)
+  })
+
+  // // ============================================================================
+  // // Transactions
+  // // ============================================================================
+
+  describe('Transactions', () => {
+    test('internalizeAction - should internalize an external transaction', async () => {
+      // This is a complex operation that requires an actual external transaction
+      // For testing purposes, we'll try with minimal parameters and expect graceful failure
+      try {
+        const dummyTxHex =
+          '01000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0100ffffffff01000000000000000000000000'
+        const result = await setup.wallet.internalizeAction({
+          tx: Array.from(Buffer.from(dummyTxHex, 'hex')),
+          outputs: [
+            {
+              outputIndex: 0,
+              protocol: 'basket insertion',
+              insertionRemittance: {
+                basket: 'default'
+              }
+            }
+          ],
+          description: 'Test internalization of external transaction'
+        })
+
+        expect(result).toBeDefined()
+      } catch (err: any) {
+        // Expected to fail with dummy data
+        expect(err).toBeDefined()
+      }
+    }, 10000)
+  })
+
+  // ============================================================================
+  // Blockchain Info
+  // ============================================================================
+
+  describe('Blockchain Info', () => {
+    test('getHeight - should fetch current block height', async () => {
+      // console.log('📊 Testing getHeight...')
+      try {
+        const result = await setup.wallet.getHeight({})
+        // console.log(`📊 Current height: ${result.height}`)
+        expect(result).toBeDefined()
+        expect(result.height).toBeDefined()
+        expect(typeof result.height).toBe('number')
+        expect(result.height).toBeGreaterThan(0)
+        // console.log('✅ getHeight test completed')
+      } catch (err: any) {
+        // If services are not configured for blockchain access, that's expected
+        // But we should still verify the method exists and returns a structured response
+        if (err.message && err.message.includes('not configured')) {
+          console.log('⚠️  Blockchain services not configured - this is expected for some test environments')
+        } else {
+          throw err
+        }
+      }
+    }, 10000)
+
+    test('getHeaderForHeight - should fetch header for specific height', async () => {
+      // console.log('📦 Testing getHeaderForHeight...')
+      try {
+        // Use a known height (e.g., block 1 or a recent block)
+        const testHeight = 1
+        const result = await setup.wallet.getHeaderForHeight({ height: testHeight })
+        // console.log(`📦 Header for height ${testHeight}: ${result.header.substring(0, 32)}...`)
+        expect(result).toBeDefined()
+        expect(result.header).toBeDefined()
+        expect(typeof result.header).toBe('string')
+        // Block header should be 80 bytes = 160 hex characters
+        expect(result.header.length).toBe(160)
+        // console.log('✅ getHeaderForHeight test completed')
+      } catch (err: any) {
+        // If services are not configured for blockchain access, that's expected
+        if (err.message && err.message.includes('not configured')) {
+          console.log('⚠️  Blockchain services not configured - this is expected for some test environments')
+        } else {
+          throw err
+        }
+      }
+    }, 10000)
+  })
+})
diff --git a/src/brc100.py.test.ts.backup b/src/brc100.py.test.ts.backup
new file mode 100644
index 0000000..3c4ebd1
--- /dev/null
+++ b/src/brc100.py.test.ts.backup
@@ -0,0 +1,1107 @@
+import { PrivateKey, Transaction, MerklePath, P2PKH, Beef, PublicKey, BEEF_V2 } from '@bsv/sdk'
+import { Setup, SetupWallet, StorageClient, Services, Chain } from '@bsv/wallet-toolbox'
+import { exit } from 'process'
+
+/**
+ * Default py-wallet-toolbox endpoint URL.
+ */
+const DEFAULT_PY_WALLET_TOOLBOX_URL = 'http://localhost:8000'
+
+/**
+ * Track nosend transaction references for cleanup.
+ * Tests that create nosend transactions should add their references here.
+ */
+const pendingAborts: string[] = []
+
+/**
+ * Global flag indicating if we're running in live test mode with funded wallet.
+ */
+const isLiveMode = process.env.LIVE === 'true' || process.env.LIVE === '1'
+
+
+/**
+ * Build Atomic BEEF from raw transaction hex.
+ *
+ * This helper function takes a raw transaction hex and:
+ * 1. Parses the transaction to get txid
+ * 2. Attempts to fetch merkle proof from Services (if mined)
+ * 3. Builds Atomic BEEF format
+ *
+ * @param rawTxHex Raw transaction hex string
+ * @param chain Network chain ('main' or 'test')
+ * @returns Atomic BEEF binary data and txid
+ */
+async function buildAtomicBeefFromRawTx(
+  rawTxHex: string,
+  chain: Chain
+): Promise<{
+  atomicBeef: number[]
+  txid: string
+}> {
+  console.log(`🔍 Parsing raw transaction (${rawTxHex.length} chars)...`)
+
+  // Parse the raw transaction to get txid
+  const tx = Transaction.fromHex(rawTxHex)
+  const txid = tx.id('hex')
+
+  console.log(`✅ Transaction parsed`)
+  console.log(`   TXID: ${txid}`)
+  console.log(`   Inputs: ${tx.inputs.length}, Outputs: ${tx.outputs.length}`)
+
+  // Use Services.getBeefForTxid() to build a valid BEEF
+  // This method handles all the complexity of fetching parent transactions
+  // and merkle proofs recursively to build a valid BEEF
+  console.log(`🔍 Building BEEF using Services.getBeefForTxid()...`)
+  const services = new Services(chain)
+
+  try {
+    const beef = await services.getBeefForTxid(txid)
+
+    console.log(`✅ BEEF built successfully`)
+    console.log(`   ${beef.toLogString()}`)
+
+    // Convert to Atomic BEEF binary format
+    const atomicBeef = beef.toBinaryAtomic(txid)
+    console.log(`   Size: ${atomicBeef.length} bytes`)
+
+    return { atomicBeef, txid }
+  } catch (error: any) {
+    console.log(`⚠️  Failed to build BEEF using Services.getBeefForTxid(): ${error.message}`)
+    console.log(`   Falling back to manual BEEF building...`)
+
+    // Fallback: Build a simple BEEF with just the transaction
+    // This may fail validation if the transaction is unconfirmed
+    const beef = new Beef(BEEF_V2)
+
+    // Try to get merkle proof for the main transaction
+    try {
+      const merkleResult = await services.getMerklePath(txid)
+      if (merkleResult && merkleResult.merklePath) {
+        tx.merklePath = merkleResult.merklePath
+        console.log(`✅ Merkle proof found (height: ${merkleResult.merklePath.blockHeight})`)
+      }
+    } catch (error: any) {
+      console.log(`⚠️  No merkle proof found - transaction may be unconfirmed`)
+    }
+
+    beef.mergeTransaction(tx)
+    const atomicBeef = beef.toBinaryAtomic(txid)
+
+    console.log(`⚠️  Built fallback BEEF (may not be valid)`)
+    console.log(`   BEEF contains ${beef.txs.length} transactions and ${beef.bumps.length} BUMPS`)
+
+    return { atomicBeef, txid }
+  }
+}
+
+describe('BRC-100 Wallet Operations (Python Storage Server)', () => {
+  let setup: SetupWallet
+  let walletServiceAvailable = false
+
+  beforeAll(async () => {
+    const endpointUrl =
+      process.env.PY_WALLET_TOOLBOX_URL || DEFAULT_PY_WALLET_TOOLBOX_URL
+    const env = Setup.getEnv('test')
+    // console.log({env})
+    // Determine which key to use
+    let rootKeyHex: string
+    if (isLiveMode && process.env.LIVE_PRIVATE_KEY) {
+      rootKeyHex = process.env.LIVE_PRIVATE_KEY
+      console.log('🔥 LIVE MODE ENABLED - Using funded testnet key')
+      console.log('⚠️  WARNING: This will broadcast real transactions!')
+    } else {
+      rootKeyHex = env.devKeys[env.identityKey]
+      console.log('🧪 TEST MODE - Using development keys')
+    }
+
+    try {
+      // Create wallet without any storage providers
+      setup = await Setup.createWallet({
+        env,
+        rootKeyHex
+      })
+
+      // Reduced verbose logging
+
+      // Create a StorageClient connected to the py-wallet-toolbox storage server
+      const storageClient = new StorageClient(setup.wallet, endpointUrl)
+      await storageClient.makeAvailable()
+      await setup.storage.addWalletStorageProvider(storageClient)
+
+      // Try to connect to verify the service is available
+      await setup.wallet.waitForAuthentication({})
+      walletServiceAvailable = true
+      // console.log({wallet: setup.wallet})
+    } catch (error: any) {
+      walletServiceAvailable = false
+      const errorMessage = error?.message || String(error)
+
+      if (
+        errorMessage.includes('fetch failed') ||
+        errorMessage.includes('ECONNREFUSED') ||
+        errorMessage.includes('Network error')
+      ) {
+        console.error(
+          '\n' +
+          '='.repeat(80) +
+          '\n' +
+          '⚠️  PY WALLET TOOLBOX STORAGE SERVER NOT AVAILABLE\n' +
+          '='.repeat(80) +
+          '\n' +
+          `\nThe py-wallet-toolbox storage server is not running at ${endpointUrl}\n` +
+          '\nTo run these tests, you need to start the py-wallet-toolbox storage server.\n' +
+          '\nSetup steps:\n' +
+          '  1. Navigate to the py-wallet-toolbox directory:\n' +
+          '     cd ../py-wallet-toolbox/examples/storage_server_example\n' +
+          '  2. Activate the virtual environment:\n' +
+          '     source venv/bin/activate  # Linux/Mac\n' +
+          '     # or\n' +
+          '     venv\\Scripts\\activate     # Windows\n' +
+          '  3. Install dependencies:\n' +
+          '     pip install -r requirements.txt\n' +
+          '  4. Run migrations:\n' +
+          '     python manage.py migrate\n' +
+          '  5. Start the storage server:\n' +
+          '     python manage.py runserver\n' +
+          '\nThe server should be available at http://localhost:8000\n' +
+          '\nFor more details, see the py-wallet-toolbox storage server README.md\n' +
+          '\n' +
+          '='.repeat(80) +
+          '\n'
+        )
+
+        // Exit early to prevent running all tests
+        process.exit(1)
+      }
+
+      // Re-throw other errors
+      throw error
+    }
+  }, 10000)
+
+  afterAll(async () => {
+    // Cleanup: Abort any pending transactions we created
+    for (const reference of pendingAborts) {
+      try {
+        await setup.wallet.abortAction({ reference })
+      } catch (err) {
+        // Already aborted or completed - ignore
+      }
+    }
+    pendingAborts.length = 0
+
+  }, 10000)
+
+  // ============================================================================
+  //   Basics
+  // ============================================================================
+
+  describe('Basics', () => {
+    test('walletInfo - should retrieve wallet address and balance', async () => {
+      // Test balance retrieval
+      let balance = 0
+      try {
+        balance = await setup.wallet.balance()
+        console.log({ balance })
+        expect(typeof balance).toBe('number')
+        expect(balance).toBeGreaterThanOrEqual(0)
+
+
+        if (isLiveMode && balance === 0) {
+          // Try to internalize funding automatically in live mode
+          try {
+            const FAUCET_DERIVATION_PREFIX = "faucet-prefix-01"
+            const FAUCET_DERIVATION_SUFFIX = "faucet-suffix-01"
+            const derivationPrefixB64 = Buffer.from(FAUCET_DERIVATION_PREFIX, 'utf-8').toString('base64')
+            const derivationSuffixB64 = Buffer.from(FAUCET_DERIVATION_SUFFIX, 'utf-8').toString('base64')
+            // Use base64 strings in keyID to match validation behavior (Go/TS use base64 strings directly)
+            const keyID = `${derivationPrefixB64} ${derivationSuffixB64}`
+
+            // Use AnyoneKey as sender (matches Python example)
+            // AnyoneKey = PrivateKey(1).public_key()
+            // PrivateKey(1) in hex is 32 bytes with value 1: '0000000000000000000000000000000000000000000000000000000000000001'
+            const anyoneKeyPriv = PrivateKey.fromString('0000000000000000000000000000000000000000000000000000000000000001')
+            const anyoneKey = anyoneKeyPriv.toPublicKey()
+            const anyoneKeyHex = anyoneKey.toString()
+
+            // Request derived public key using BRC-29 protocol (wallet payment protocol)
+            // Use AnyoneKey as counterparty (external sender, like a faucet)
+            // NOTE: keyID uses base64 strings to match validation behavior (Go/TS use base64 strings directly)
+            // NOTE: forSelf=true to match AddressForSelf direction (recipient derives for self)
+            // This matches validation which uses derivePrivateKey (recipient's perspective)
+            const derivedKeyResult = await setup.wallet.getPublicKey({
+              protocolID: [2, '3241645161d8'], // BRC-29 wallet payment protocol
+              keyID: keyID, // Base64 strings (matches Go/TS validation)
+              counterparty: anyoneKeyHex, // Use AnyoneKey for external sender (faucet)
+              forSelf: true // CRITICAL: Must be true to match AddressForSelf direction
+            })
+
+            if (!derivedKeyResult.publicKey) {
+              throw new Error('Failed to get derived public key from wallet')
+            }
+
+            // Create P2PKH address from derived public key
+            const derivedPublicKey = PublicKey.fromString(derivedKeyResult.publicKey)
+            const network = setup.chain === 'main' ? 'mainnet' : 'testnet'
+            const fundingAddress = derivedPublicKey.toAddress(network)
+            // console.log('📬 EXTERNAL FUNDING ADDRESS (P2PKH)')
+            console.log('Address:', fundingAddress)
+
+            // Check if the funding address has funds via Whatsonchain API
+            const wocNetwork = setup.chain === 'main' ? 'main' : 'test'
+            const wocBaseUrl = `https://api.whatsonchain.com/v1/bsv/${wocNetwork}`
+
+            try {
+              // Check for unspent outputs at this address
+              const unspentResponse = await fetch(`${wocBaseUrl}/address/${fundingAddress}/unspent`)
+              if (!unspentResponse.ok) {
+                throw new Error(`Whatsonchain API error: ${unspentResponse.statusText}`)
+              }
+
+              const unspentData = await unspentResponse.json()
+              console.log(`📊 Found ${unspentData.length} unspent output(s) at funding address`)
+
+              if (unspentData.length > 0) {
+                // Get the first unspent output (or we could process all of them)
+                const firstUtxo = unspentData[0]
+                const txid = firstUtxo.tx_hash
+                const outputIndex = firstUtxo.tx_pos
+
+                // console.log(`📥 Found funding transaction: ${txid}:${outputIndex}`)
+                // console.log(`💰 Amount: ${firstUtxo.value} satoshis`)
+
+                // Show Whatsonchain link for the funding transaction
+                const wocNetwork = setup.chain === 'main' ? '' : 'test.'
+                const fundingTxUrl = `https://${wocNetwork}whatsonchain.com/tx/${txid}`
+                console.log(`🔗 View funding transaction on Whatsonchain: ${fundingTxUrl}`)
+
+                // Get the raw transaction hex
+                const txResponse = await fetch(`${wocBaseUrl}/tx/${txid}/hex`)
+                if (!txResponse.ok) {
+                  throw new Error(`Failed to fetch transaction: ${txResponse.statusText}`)
+                }
+
+                const txHex = await txResponse.text()
+                // console.log(`📄 Retrieved raw transaction (${txHex.length / 2} bytes)`)
+                // TODO: replace things below with buildAtomicBeefFromRawTx
+                // Parse the transaction to verify the output
+                const txBytes = Array.from(Buffer.from(txHex, 'hex'))
+                const tx = Transaction.fromBinary(txBytes)
+
+                // Verify the output at the specified index pays to our address
+                if (outputIndex >= tx.outputs.length) {
+                  throw new Error(`Output index ${outputIndex} out of range (${tx.outputs.length} outputs)`)
+                }
+
+                const output = tx.outputs[outputIndex]
+                // Verify the output pays to our address by comparing locking scripts
+                const expectedLockingScript = new P2PKH().lock(fundingAddress)
+                const actualLockingScript = output.lockingScript.toHex()
+                const expectedLockingScriptHex = expectedLockingScript.toHex()
+
+                console.log(`   Output ${outputIndex} locking script: ${actualLockingScript}`)
+                console.log(`   Expected locking script: ${expectedLockingScriptHex}`)
+
+                if (actualLockingScript !== expectedLockingScriptHex) {
+                  console.log(`⚠️  Warning: Output ${outputIndex} locking script does not match funding address`)
+                  console.log(`   This output may not be a BRC-29 wallet payment - it might be a regular P2PKH`)
+                  // Continue anyway - might be a different output format
+                } else {
+                  console.log(`✅ Output ${outputIndex} locking script matches funding address`)
+                }
+
+                // Build Atomic BEEF using the helper function
+                const { atomicBeef, txid: beefTxid } = await buildAtomicBeefFromRawTx(txHex, setup.chain)
+
+                try {
+                  // Prepare payment remittance with proper base64 encoding
+                  // Match Python example: use AnyoneKey as senderIdentityKey (external sender/faucet)
+                  // NOTE: derivationPrefix and derivationSuffix are already base64-encoded above
+                  const paymentRemittance = {
+                    derivationPrefix: derivationPrefixB64, // Already base64-encoded
+                    derivationSuffix: derivationSuffixB64, // Already base64-encoded
+                    senderIdentityKey: anyoneKeyHex // Use AnyoneKey (external sender, like faucet)
+                  }
+
+                  console.log(`   Payment remittance:`, {
+                    derivationPrefix: paymentRemittance.derivationPrefix,
+                    derivationSuffix: paymentRemittance.derivationSuffix,
+                    derivationPrefixDecoded: Buffer.from(paymentRemittance.derivationPrefix, 'base64').toString('utf-8'),
+                    derivationSuffixDecoded: Buffer.from(paymentRemittance.derivationSuffix, 'base64').toString('utf-8'),
+                    senderIdentityKey: paymentRemittance.senderIdentityKey.substring(0, 20) + '... (AnyoneKey)'
+                  })
+
+                  // Internalize as "wallet payment" protocol (matches Python example)
+                  // Python example always uses "wallet payment" protocol with paymentRemittance
+                  const internalizeResult = await setup.wallet.internalizeAction({
+                    tx: atomicBeef,
+                    outputs: [
+                      {
+                        outputIndex: outputIndex,
+                        protocol: 'wallet payment',
+                        paymentRemittance: paymentRemittance
+                      }
+                    ],
+                    description: 'Auto-internalize funding transaction'
+                  })
+
+                  console.log('✅ Successfully internalized as wallet payment')
+
+                  if (internalizeResult) {
+                    console.log(`✅ Successfully internalized funding transaction`)
+                    console.log(`   Accepted: ${internalizeResult.accepted}`)
+                    console.log(`   TXID: ${txid}`)
+
+                    // Show Whatsonchain link
+                    const wocNetwork = setup.chain === 'main' ? '' : 'test.'
+                    const fundingTxUrl = `https://${wocNetwork}whatsonchain.com/tx/${txid}`
+                    console.log(`🔗 View funding transaction on Whatsonchain: ${fundingTxUrl}`)
+
+                    // Check balance again after internalization
+                    const newBalance = await setup.wallet.balance()
+                    console.log(`💰 New balance after internalization: ${newBalance} satoshis`)
+                  }
+                } catch (internalizeErr: any) {
+                  // Final fallback - log and continue
+                  console.log('⚠️  Could not internalize transaction:', internalizeErr.message)
+
+                  if (internalizeErr.message.includes('BRC-29') || internalizeErr.message.includes('locking script')) {
+                    console.log('   The output is a regular P2PKH (not created with BRC-29)')
+                    console.log('   The wallet may still be able to spend it if it can derive the private key')
+                  } else if (internalizeErr.message.includes('AtomicBEEF')) {
+                    console.log('   The BEEF may be missing merkle proofs (BUMPS)')
+                    console.log('   This is expected when fetching transactions from external APIs')
+                  }
+
+                  console.log('   This is best-effort automatic funding - continuing without internalization')
+                  // Continue without exiting - this is best-effort automatic funding
+                }
+              } else {
+                console.log('ℹ️  No unspent outputs found at funding address')
+                exit(-1)
+              }
+            } catch (apiErr: any) {
+              console.log('   Could not check external API:', apiErr.message)
+              // Don't throw - this is best-effort automatic funding
+              // Continue without exiting
+            }
+          } catch (apiErr) {
+            console.log('   Could not check external API')
+          }
+        }
+      } catch (err: any) {
+        console.log('⚠️  Balance check failed (expected for local testing)')
+        if (isLiveMode) {
+          console.log(
+            '   This may indicate services are not configured for live testing.'
+          )
+        }
+        // Balance might fail if services not configured, but that's expected
+      }
+      // Test completed
+    }, 10000)
+
+    test('waitForAuthentication - should resolve immediately for base wallet', async () => {
+      console.log('🔐 Testing waitForAuthentication...')
+      const result = await setup.wallet.waitForAuthentication({})
+      console.log(`🔐 Authentication result: ${JSON.stringify(result)}`)
+      expect(result).toBeDefined()
+      expect(result.authenticated).toBeDefined()
+      // Base wallet resolves immediately
+      console.log('✅ waitForAuthentication test completed')
+    }, 10000)
+
+    test('isAuthenticated - should check if wallet is authenticated', async () => {
+      console.log('🔐 Testing isAuthenticated...')
+      const result = await setup.wallet.isAuthenticated({})
+      console.log(`🔐 Authentication check result: ${JSON.stringify(result)}`)
+      expect(result).toBeDefined()
+      expect(result.authenticated).toBeDefined()
+      expect(typeof result.authenticated).toBe('boolean')
+      console.log('✅ isAuthenticated test completed')
+    }, 10000)
+
+    test('getNetwork - should return the network information', async () => {
+      console.log('🌐 Testing getNetwork...')
+      const result = await setup.wallet.getNetwork({})
+      console.log(`🌐 Network info: ${JSON.stringify(result)}`)
+      expect(result).toBeDefined()
+      expect(result.network).toBeDefined()
+      expect(['main', 'test', 'testnet']).toContain(result.network)
+      console.log('✅ getNetwork test completed')
+    }, 10000)
+
+    test('getVersion - should return wallet version information', async () => {
+      console.log('📦 Testing getVersion...')
+      const result = await setup.wallet.getVersion({})
+      console.log(`📦 Version info: ${JSON.stringify(result)}`)
+      expect(result).toBeDefined()
+      expect(result.version).toBeDefined()
+      expect(typeof result.version).toBe('string')
+      console.log('✅ getVersion test completed')
+    }, 10000)
+  })
+
+  // ============================================================================
+  // Keys and Signatures
+  // ============================================================================
+
+  describe('Keys and Signatures', () => {
+    test('getPublicKey - should derive protocol-specific public key', async () => {
+      console.log('🔑 Testing public key derivation...')
+      const result = await setup.wallet.getPublicKey({
+        identityKey: true,
+        protocolID: [0, 'testprotocol'],
+        keyID: '1',
+        counterparty: 'self'
+      })
+
+      console.log(
+        `🔑 Derived public key: ${result.publicKey.substring(0, 20)}...`
+      )
+      expect(result).toBeDefined()
+      expect(result.publicKey).toBeDefined()
+      expect(typeof result.publicKey).toBe('string')
+      expect(result.publicKey.length).toBeGreaterThan(60) // Public key length
+      console.log('✅ Public key test completed')
+    }, 10000)
+
+    test('createSignature - should sign data with wallet keys', async () => {
+      console.log('✍️  Testing signature creation...')
+      const testMessage = 'Hello, BSV!'
+      const data = Array.from(Buffer.from(testMessage))
+
+      const result = await setup.wallet.createSignature({
+        data,
+        protocolID: [0, 'testprotocol'],
+        keyID: '1',
+        counterparty: 'self'
+      })
+      console.log(
+        `✍️  Created signature: ${Buffer.from(result.signature.slice(0, 10)).toString('hex')}...`
+      )
+      expect(result).toBeDefined()
+      expect(result.signature).toBeDefined()
+      console.log('✅ Signature creation test completed')
+    }, 10000)
+
+    test('verifySignature - should create and verify signature round-trip', async () => {
+      console.log('🔍 Testing signature verification...')
+      const testMessage = 'Test signature verification'
+      const data = Array.from(Buffer.from(testMessage))
+
+      // Create signature
+      const createResult = await setup.wallet.createSignature({
+        data,
+        protocolID: [0, 'testprotocol'],
+        keyID: '1',
+        counterparty: 'self'
+      })
+
+      // Verify signature
+      const verifyResult = await setup.wallet.verifySignature({
+        data,
+        signature: createResult.signature,
+        protocolID: [0, 'testprotocol'],
+        keyID: '1',
+        counterparty: 'self'
+      })
+
+      console.log(`🔍 Signature verification result: ${verifyResult.valid}`)
+      expect(verifyResult).toBeDefined()
+      expect(verifyResult.valid).toBe(true)
+      console.log('✅ Signature verification test completed')
+    }, 10000)
+
+    test('revealCounterpartyKeyLinkage - should reveal counterparty key linkage', async () => {
+      try {
+        const result = await setup.wallet.revealCounterpartyKeyLinkage({
+          counterparty: 'self',
+          verifier: '02' + 'a'.repeat(64), // demo verifier pubkey
+          privilegedReason: 'Demo'
+        })
+
+        expect(result).toBeDefined()
+        expect(result.prover).toBeDefined()
+        expect(result.counterparty).toBeDefined()
+      } catch (err: any) {
+        // This might fail in test environments, which is expected
+      }
+    }, 10000)
+
+    test('revealSpecificKeyLinkage - should reveal specific key linkage', async () => {
+      try {
+        const result = await setup.wallet.revealSpecificKeyLinkage({
+          counterparty: 'self',
+          verifier: '02' + 'a'.repeat(64), // demo verifier pubkey
+          protocolID: [0, 'testprotocol'],
+          keyID: '1',
+          privilegedReason: 'Demo'
+        })
+
+        expect(result).toBeDefined()
+        expect(result.prover).toBeDefined()
+        expect(result.counterparty).toBeDefined()
+        expect(result.protocolID).toBeDefined()
+        expect(result.keyID).toBeDefined()
+      } catch (err: any) {
+        // This might fail in test environments, which is expected
+      }
+    }, 10000)
+  })
+
+  // // ============================================================================
+  // // Crypto Operations
+  // // ============================================================================
+
+  describe('Crypto Operations', () => {
+    test('createHmac - should generate HMAC for message', async () => {
+      console.log('🔐 Testing HMAC creation...')
+      const testMessage = 'Hello, HMAC!'
+      const data = Array.from(Buffer.from(testMessage))
+
+      const result = await setup.wallet.createHmac({
+        data,
+        protocolID: [0, 'testprotocol'],
+        keyID: '1',
+        counterparty: 'self'
+      })
+
+      console.log(
+        `🔐 Generated HMAC: ${Buffer.from(result.hmac.slice(0, 10)).toString('hex')}...`
+      )
+      expect(result).toBeDefined()
+      expect(result.hmac).toBeDefined()
+      console.log('✅ HMAC creation test completed')
+    }, 10000)
+
+    test('verifyHmac - should create and verify HMAC round-trip', async () => {
+      console.log('🔍 Testing HMAC verification...')
+      const testMessage = 'Test HMAC verification'
+      const data = Array.from(Buffer.from(testMessage))
+
+      // Create HMAC
+      const createResult = await setup.wallet.createHmac({
+        data,
+        protocolID: [0, 'testprotocol'],
+        keyID: '1',
+        counterparty: 'self'
+      })
+
+      // Verify HMAC
+      const verifyResult = await setup.wallet.verifyHmac({
+        data,
+        hmac: createResult.hmac,
+        protocolID: [0, 'testprotocol'],
+        keyID: '1',
+        counterparty: 'self'
+      })
+
+      console.log(`🔍 HMAC verification result: ${verifyResult.valid}`)
+      console.log('✅ HMAC verification test completed')
+      expect(verifyResult).toBeDefined()
+      expect(verifyResult.valid).toBe(true)
+      console.log('✅ HMAC verification test completed')
+    }, 10000)
+
+    test('encrypt/decrypt - should encrypt data and decrypt it back', async () => {
+      console.log('🔒 Testing encryption/decryption...')
+      const testMessage = 'Secret Message!'
+      const plaintext = Array.from(Buffer.from(testMessage))
+
+      // Encrypt
+      const encryptResult = await setup.wallet.encrypt({
+        plaintext,
+        protocolID: [0, 'encryption'],
+        keyID: '1',
+        counterparty: 'self'
+      })
+
+      console.log(
+        `🔒 Encrypted message: ${Buffer.from(encryptResult.ciphertext.slice(0, 10)).toString('hex')}...`
+      )
+      expect(encryptResult).toBeDefined()
+      expect(encryptResult.ciphertext).toBeDefined()
+
+      // Decrypt
+      const decryptResult = await setup.wallet.decrypt({
+        ciphertext: encryptResult.ciphertext,
+        protocolID: [0, 'encryption'],
+        keyID: '1',
+        counterparty: 'self'
+      })
+
+      expect(decryptResult).toBeDefined()
+      expect(decryptResult.plaintext).toBeDefined()
+      expect(Array.isArray(decryptResult.plaintext)).toBe(true)
+
+      // Verify decrypted message matches original
+      const decrypted = Buffer.from(decryptResult.plaintext).toString()
+      console.log(`🔓 Decrypted message: "${decrypted}"`)
+      expect(decrypted).toBe(testMessage)
+      console.log('✅ Encryption/decryption test completed')
+    }, 10000)
+  })
+
+  // ============================================================================
+  // Actions
+  // ============================================================================
+
+  describe('Actions', () => {
+    test('createAction - should create OP_RETURN transaction (noSend + abort)', async () => {
+      console.log(`Starting createAction test ${isLiveMode ? '(LIVE)' : '(test mode)'}`)
+
+      // Check balance first - need at least 10 sats to safely run this test
+      // For externally-funded outputs, also check the 'funding' basket
+      let balance = 0
+      try {
+        balance = await setup.wallet.balance()
+        console.log({ balance })
+
+      } catch (err) {
+        console.log('⚠️  Could not check balance - assuming 0')
+      }
+
+      const requiredBalance = 10
+      if (balance < requiredBalance) {
+        if (isLiveMode) {
+          console.log(
+            `❌ LIVE MODE: Insufficient balance (${balance} < ${requiredBalance} sats)`
+          )
+          console.log('   Fund your wallet before running live tests.')
+          throw new Error('Insufficient funds for live testing')
+        } else {
+          console.log('⚠️  Skipping test - insufficient balance')
+          return
+        }
+      }
+
+      try {
+        const message = 'Hello, World! - Test Action'
+        const messageBytes = Buffer.from(message)
+        const hexData = messageBytes.toString('hex')
+        const length = messageBytes.length
+        const lockingScript = `006a${length.toString(16).padStart(2, '0')}${hexData}`
+
+        const shouldBroadcast = isLiveMode
+        let action: any
+        try {
+          action = await setup.wallet.createAction({
+            description: `Test action: ${message}`,
+            outputs: [
+              { lockingScript, satoshis: 0, outputDescription: 'Test output', basket: 'opreturn', tags: ['test'] }
+            ],
+            labels: ['test:create_action'],
+            options: {
+              noSend: !shouldBroadcast,
+              acceptDelayedBroadcast: shouldBroadcast ? false : true
+            }
+          })
+        } catch (error: any) {
+          // When acceptDelayedBroadcast is false, unsuccessful results throw WERR_REVIEW_ACTIONS
+          // Extract the results from the error and treat as action result
+          if (error.name === 'WERR_REVIEW_ACTIONS' || error.message?.includes('require review')) {
+            console.log('⚠️  Action requires review (undelayed mode)')
+            action = {
+              txid: error.txid,
+              tx: error.tx,
+              sendWithResults: error.sendWithResults || [],
+              reviewActionResults: error.reviewActionResults || [],
+              noSendChange: error.noSendChange
+            }
+            console.dir(action, { depth: null })
+            
+            // Log review results
+            if (action.reviewActionResults && action.reviewActionResults.length > 0) {
+              // Fail the test if any review action result has an error status
+              const errorResults = action.reviewActionResults.filter((result: any) => result.status === 'error')
+              if (errorResults.length > 0) {
+                const errorMessages = errorResults.map((result: any) =>
+                  `${result.txid}: ${result.message || 'Unknown error'}`
+                ).join('; ')
+                console.error(`❌ Review action failed with errors: ${errorMessages}`)
+                // Use expect().toBe() to fail the test explicitly
+                expect(errorResults.length).toBe(0)
+              }
+            }
+            
+            // Also check sendWithResults for failures
+            if (action.sendWithResults && Array.isArray(action.sendWithResults)) {
+              const failedResults = action.sendWithResults.filter((result: any) => result.status === 'failed')
+              if (failedResults.length > 0) {
+                const errorMessages = failedResults.map((result: any) => 
+                  `${result.txid}: ${result.message || 'Broadcast failed'}`
+                ).join('; ')
+                console.error(`❌ Send action failed: ${errorMessages}`)
+                // Use expect().toBe() to fail the test explicitly
+                expect(failedResults.length).toBe(0)
+              }
+            }
+          } else {
+            // Some other error - log details and rethrow
+            console.error('❌ createAction failed with error:', error.name || error.constructor?.name)
+            console.error('   Message:', error.message)
+            if (error.stack) {
+              console.error('   Stack:', error.stack)
+            }
+            // Check for script evaluation errors
+            if (error.message && (error.message.includes('OP_EQUALVERIFY') || error.message.includes('Script evaluation'))) {
+              console.error('🔍 Script evaluation error detected - this usually means the unlocking script does not match the locking script')
+              console.error('   This can happen if:')
+              console.error('   1. The derivation fields (derivationPrefix/derivationSuffix) do not match the public key in the locking script')
+              console.error('   2. The counterparty type (SELF vs OTHER) is incorrect')
+              console.error('   3. The identity key used for derivation does not match')
+              console.error('   4. The output was internalized incorrectly (wrong protocol or missing derivation data)')
+            }
+            throw error
+          }
+        }
+        
+        // Also show links for sendWithResults if available
+        if (action.notDelayedResults && Array.isArray(action.notDelayedResults)) {
+          action.notDelayedResults.forEach((result: any) => {
+            if (result.txid && result.status === 'success') {
+              const chain = setup.wallet.chain || 'test'
+              const network = chain === 'main' ? '' : 'test.'
+              const whatsonchainUrl = `https://${network}whatsonchain.com/tx/${result.txid}`
+              console.log(`🔗 View transaction ${result.txid} on Whatsonchain: ${whatsonchainUrl}`)
+              console.log(`   Status: ${result.status}`)
+            }
+
+            // Only fail the test if the transaction actually failed to broadcast
+            if (result.status === 'failed') {
+              throw new Error(`Transaction ${result.txid} failed with status ${result.status}`)
+            }
+          })
+        }
+//        console.log(`✅ Action created with ${action.signableTransaction ? 'signableTransaction' : action.txid ? 'txid' : 'unknown'}`)
+
+      } catch (err: any) {
+        if (
+          err.message.includes('Insufficient funds') ||
+          err.message.includes('insufficient')
+        )
+          return
+        throw err
+      }
+    }, 15000)
+
+    test('createAction - verify action result structure', async () => {
+      // Check balance first
+      let balance = 0
+      try {
+        balance = await setup.wallet.balance()
+        console.log(`💰 Current balance: ${balance} satoshis`)
+      } catch (err) {
+        console.log('⚠️  Could not check balance - assuming 0')
+      }
+
+      if (balance < 10 && !isLiveMode) {
+        console.log('⚠️  Skipping structure test - insufficient balance')
+        return
+      }
+
+      try {
+        const message = 'Structure Test' + (isLiveMode ? ' (LIVE)' : '')
+        const messageBytes = Buffer.from(message)
+        const hexData = messageBytes.toString('hex')
+        const length = messageBytes.length
+        const lockingScript = `006a${length.toString(16).padStart(2, '0')}${hexData}`
+
+        const shouldBroadcast = isLiveMode && balance >= 10
+
+        let action
+        try {
+          action = await setup.wallet.createAction({
+            description: `Structure test: ${message}`,
+            outputs: [
+              {
+                lockingScript,
+                satoshis: 0,
+                outputDescription: 'Test output',
+                basket: 'opreturn',
+                tags: ['test', ...(isLiveMode ? ['live-test'] : ['test-nosend'])]
+              }
+            ],
+            labels: ['test:structure'],
+            options: {
+              noSend: !shouldBroadcast
+            }
+          })
+
+        } catch (err: any) {
+          console.error('❌ createAction failed:', err.message)
+          throw err
+        }
+
+        console.log(
+          `✅ Structure test action created with ${action.signableTransaction ? 'signableTransaction' : action.txid ? 'txid' : 'unknown'}`
+        )
+        expect(action).toBeDefined()
+
+        if (shouldBroadcast) {
+          // In live mode, expect txid
+          expect(action.txid).toBeDefined()
+          expect(typeof action.txid).toBe('string')
+          expect(action.txid!.length).toBe(64)
+          console.log(`📡 Transaction broadcasted! TXID: ${action.txid}`)
+          console.log(
+            `🔗 View on explorer: https://test.whatsonchain.com/tx/${action.txid}`
+          )
+        } else {
+          // Verify result structure - either signableTransaction or txid
+          if (action.signableTransaction) {
+            expect(action.signableTransaction.reference).toBeDefined()
+            expect(action.signableTransaction.tx).toBeDefined()
+            console.log(
+              `📝 Keeping action ${action.signableTransaction.reference} for database verification`
+            )
+            // Keep this action for the listActions test to find it
+            // Don't abort immediately - will be cleaned up in afterAll
+          } else if (action.txid) {
+            expect(typeof action.txid).toBe('string')
+            expect(action.txid!.length).toBe(64)
+          } else {
+            throw new Error('Expected either signableTransaction or txid')
+          }
+        }
+      } catch (err: any) {
+        if (
+          err.message.includes('Insufficient funds') ||
+          err.message.includes('insufficient')
+        )
+          return
+        throw err
+      }
+    }, 15000)
+
+    test('listActions - should list recent wallet actions', async () => {
+      const actions = await setup.wallet.listActions({
+        labels: [],
+        limit: 10,
+        includeLabels: true
+      })
+
+      expect(actions).toBeDefined()
+      expect(actions.actions).toBeDefined()
+      expect(Array.isArray(actions.actions)).toBe(true)
+      expect(actions.actions.length).toBeGreaterThanOrEqual(0)
+    }, 10000)
+
+    test('abortAction - should abort an unsigned action if available', async () => {
+      // Check if there are any unsigned actions we can abort
+      const actions = await setup.wallet.listActions({ labels: [], limit: 20 })
+      const unsignedAction = actions.actions.find(
+        a => a.status === 'unsigned' || a.status === 'nosend'
+      )
+
+      // listActions doesn't return references, so we can only abort
+      // actions we created in the same session with signableTransaction
+      expect(unsignedAction === undefined || unsignedAction.status).toBeTruthy()
+    }, 10000)
+  })
+
+  // ============================================================================
+  // Outputs
+  // ============================================================================
+
+  describe('Outputs', () => {
+    test('listOutputs - should list wallet outputs', async () => {
+      const outputs = await setup.wallet.listOutputs({
+        basket: 'default',
+        limit: 10,
+        offset: 0
+      })
+
+      expect(outputs).toBeDefined()
+      expect(outputs.outputs).toBeDefined()
+      expect(Array.isArray(outputs.outputs)).toBe(true)
+      expect(typeof outputs.totalOutputs).toBe('number')
+      expect(outputs.totalOutputs).toBeGreaterThanOrEqual(0)
+    }, 10000)
+
+    test('relinquishOutput - should relinquish an output from wallet tracking', async () => {
+      // Use a dummy outpoint since we likely don't have real outputs to relinquish
+      const dummyOutpoint =
+        '0000000000000000000000000000000000000000000000000000000000000000:0'
+
+      try {
+        const result = await setup.wallet.relinquishOutput({
+          basket: 'default',
+          output: dummyOutpoint
+        })
+
+        expect(result).toBeDefined()
+        expect(result.relinquished).toBeDefined()
+      } catch (err: any) {
+        // Expected to fail with dummy outpoint
+        expect(err).toBeDefined()
+      }
+    }, 10000)
+  })
+
+  // ============================================================================
+  // Certificates
+  // ============================================================================
+
+  describe('Certificates', () => {
+    test('acquireCertificate - should attempt to acquire a certificate', async () => {
+      try {
+        const result = await setup.wallet.acquireCertificate({
+          type: Buffer.from('test-certificate').toString('base64'),
+          certifier: setup.identityKey,
+          acquisitionProtocol: 'issuance',
+          certifierUrl: 'http://localhost:9999',
+          fields: {
+            name: 'Test User',
+            email: 'test@example.com'
+          },
+          privilegedReason: 'Demo acquisition'
+        })
+        expect(result).toBeDefined()
+      } catch (err: any) {
+        // Expected to fail - there's no real certifier service running
+        expect(err).toBeDefined()
+      }
+    }, 10000)
+
+    test('listCertificates - should list wallet certificates', async () => {
+      const certs = await setup.wallet.listCertificates({
+        certifiers: [],
+        types: [],
+        limit: 10,
+        offset: 0
+      })
+
+      expect(certs).toBeDefined()
+      expect(certs.certificates).toBeDefined()
+      expect(Array.isArray(certs.certificates)).toBe(true)
+      expect(certs.certificates.length).toBeGreaterThanOrEqual(0)
+      if (certs.certificates.length > 0) {
+        const testCert = certs.certificates.find(
+          c => c.type === 'test-certificate'
+        )
+        if (testCert) {
+          expect(testCert.subject).toBeDefined()
+        }
+      }
+    }, 10000)
+
+    test('relinquishCertificate - should relinquish a certificate', async () => {
+      // First check if we have any certificates to relinquish
+      const certs = await setup.wallet.listCertificates({
+        certifiers: [],
+        types: [],
+        limit: 10,
+        offset: 0
+      })
+
+      if (certs.certificates.length === 0) {
+        console.log('⚠️  No certificates to relinquish, skipping test')
+        return
+      }
+
+      // Try to relinquish the first certificate
+      const cert = certs.certificates[0]
+
+      try {
+        await setup.wallet.relinquishCertificate({
+          type: cert.type,
+          certifier: cert.certifier || 'self',
+          serialNumber: cert.serialNumber || ''
+        })
+      } catch (err: any) {
+        // Expected to fail in test environment
+        expect(err).toBeDefined()
+      }
+    }, 10000)
+  })
+
+  // ============================================================================
+  // Identity Discovery
+  // ============================================================================
+
+  describe('Identity Discovery', () => {
+    test('discoverByIdentityKey - should discover certificates by identity key', async () => {
+      try {
+        const result = await setup.wallet.discoverByIdentityKey({
+          identityKey: setup.identityKey,
+          limit: 10,
+          offset: 0,
+          seekPermission: true
+        })
+
+        expect(result).toBeDefined()
+        expect(result.certificates).toBeDefined()
+        expect(Array.isArray(result.certificates)).toBe(true)
+      } catch (err: any) {
+        // Expected to fail in test environment
+        expect(err).toBeDefined()
+      }
+    }, 10000)
+
+    test('discoverByAttributes - should discover certificates by attributes', async () => {
+      try {
+        const result = await setup.wallet.discoverByAttributes({
+          attributes: { verified: 'true' },
+          limit: 10,
+          offset: 0
+        })
+
+        expect(result).toBeDefined()
+        expect(result.certificates).toBeDefined()
+        expect(Array.isArray(result.certificates)).toBe(true)
+      } catch (err: any) {
+        // Expected to fail in test environment
+        expect(err).toBeDefined()
+      }
+    }, 10000)
+  })
+
+  // // ============================================================================
+  // // Transactions
+  // // ============================================================================
+
+  describe('Transactions', () => {
+    test('internalizeAction - should internalize an external transaction', async () => {
+      // This is a complex operation that requires an actual external transaction
+      // For testing purposes, we'll try with minimal parameters and expect graceful failure
+      try {
+        const dummyTxHex =
+          '01000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0100ffffffff01000000000000000000000000'
+        const result = await setup.wallet.internalizeAction({
+          tx: Array.from(Buffer.from(dummyTxHex, 'hex')),
+          outputs: [
+            {
+              outputIndex: 0,
+              protocol: 'basket insertion',
+              insertionRemittance: {
+                basket: 'default'
+              }
+            }
+          ],
+          description: 'Test internalization of external transaction'
+        })
+
+        expect(result).toBeDefined()
+      } catch (err: any) {
+        // Expected to fail with dummy data
+        expect(err).toBeDefined()
+      }
+    }, 10000)
+  })
+
+  // // ============================================================================
+  // // Blockchain Info
+  // // ============================================================================
+
+  describe.skip('Blockchain Info', () => {
+    test('getHeight - should fetch current block height', async () => {
+      // Skipped for Python storage server tests - requires external blockchain API
+    }, 10000)
+
+    test('getHeaderForHeight - should fetch header for specific height', async () => {
+      // Skipped for Python storage server tests - requires external blockchain API
+    }, 10000)
+  })
+})
diff --git a/src/brc100.test.ts b/src/brc100.test.ts
new file mode 100644
index 0000000..003326e
--- /dev/null
+++ b/src/brc100.test.ts
@@ -0,0 +1,723 @@
+import { PrivateKey } from '@bsv/sdk'
+import { Setup, SetupWallet, StorageClient } from '@bsv/wallet-toolbox'
+import { execSync } from 'child_process'
+
+/**
+ * Default local wallet-infra endpoint URL.
+ */
+const DEFAULT_WALLET_INFRA_URL = 'http://localhost:8080'
+
+/**
+ * Track nosend transaction references for cleanup.
+ * Tests that create nosend transactions should add their references here.
+ */
+const pendingAborts: string[] = []
+
+/**
+ * Cleanup nosend transactions by failing them and releasing their UTXOs.
+ * This uses direct database access for test cleanup.
+ */
+async function cleanupNosendTransactions(): Promise<number> {
+  try {
+    // Fail all nosend transactions and release their outputs
+    const result = execSync(
+      `docker exec mysql mysql -uroot -prootPass wallet_storage -e "
+      -- Get nosend transaction IDs
+      SET @nosend_ids = (SELECT GROUP_CONCAT(transactionId) FROM transactions WHERE status='nosend');
+      
+      -- Release outputs consumed by nosend transactions
+      UPDATE outputs SET spendable=1, spentBy=NULL 
+      WHERE spentBy IN (SELECT transactionId FROM transactions WHERE status='nosend');
+      
+      -- Mark nosend transactions as failed
+      UPDATE transactions SET status='failed' WHERE status='nosend';
+      
+      -- Count how many we cleaned up
+      SELECT COUNT(*) as cleaned FROM transactions WHERE status='failed' AND satoshis=-1;
+    " 2>/dev/null`,
+      { encoding: 'utf-8' }
+    )
+
+    const match = result.match(/cleaned\n(\d+)/)
+    return match ? parseInt(match[1]) : 0
+  } catch (err) {
+    // Docker/MySQL not available - skip cleanup
+    return 0
+  }
+}
+
+describe('BRC-100 Wallet Operations', () => {
+  let setup: SetupWallet
+  let walletServiceAvailable = false
+
+  beforeAll(async () => {
+    const endpointUrl = process.env.WALLET_INFRA_URL || DEFAULT_WALLET_INFRA_URL
+    const env = Setup.getEnv('test')
+
+    try {
+      // Create wallet without any storage providers
+      setup = await Setup.createWallet({
+        env,
+        rootKeyHex: env.devKeys[env.identityKey]
+      })
+
+      // Create a StorageClient connected to the local wallet-infra
+      const storageClient = new StorageClient(setup.wallet, endpointUrl)
+      await storageClient.makeAvailable()
+      await setup.storage.addWalletStorageProvider(storageClient)
+
+      // Try to connect to verify the service is available
+      await setup.wallet.waitForAuthentication({})
+      walletServiceAvailable = true
+
+      // Clean up any leftover nosend transactions from previous runs
+      await cleanupNosendTransactions()
+    } catch (error: any) {
+      walletServiceAvailable = false
+      const errorMessage = error?.message || String(error)
+
+      if (
+        errorMessage.includes('fetch failed') ||
+        errorMessage.includes('ECONNREFUSED') ||
+        errorMessage.includes('Network error')
+      ) {
+        console.error(
+          '\n' +
+            '='.repeat(80) +
+            '\n' +
+            '⚠️  WALLET SERVICE NOT AVAILABLE\n' +
+            '='.repeat(80) +
+            '\n' +
+            `\nThe wallet infrastructure service is not running at ${endpointUrl}\n` +
+            '\nTo run these tests, you need to start the wallet-infra service.\n' +
+            '\nYou can use the wallet-infra repository to start the service:\n' +
+            '  1. Navigate to the wallet-infra directory:\n' +
+            '     cd ../wallet-infra\n' +
+            '  2. Start the service using Docker Compose:\n' +
+            '     docker compose up --build\n' +
+            '\nAlternatively, you can use wallet-infra-bsva:\n' +
+            '     cd ../wallet-infra-bsva\n' +
+            '     docker compose up --build\n' +
+            '\nThe service should be available at http://localhost:8080\n' +
+            '\nFor more details, see:\n' +
+            '  - wallet-infra/guides/local_development.md\n' +
+            '  - wallet-infra-bsva/guides/local_development.md\n' +
+            '\n' +
+            '='.repeat(80) +
+            '\n'
+        )
+
+        // Exit early to prevent running all tests
+        process.exit(1)
+      }
+
+      // Re-throw other errors
+      throw error
+    }
+  }, 10000)
+
+  afterAll(async () => {
+    // Cleanup: Abort any pending transactions we created
+    for (const reference of pendingAborts) {
+      try {
+        await setup.wallet.abortAction({ reference })
+      } catch (err) {
+        // Already aborted or completed - ignore
+      }
+    }
+    pendingAborts.length = 0
+
+    // Clean up nosend transactions created during this run
+    await cleanupNosendTransactions()
+  }, 10000)
+
+  // ============================================================================
+  // Basics
+  // ============================================================================
+
+  describe('Basics', () => {
+    test('walletInfo - should retrieve wallet address and balance', async () => {
+      const env = Setup.getEnv(setup.chain)
+
+      // Test address derivation
+      const address = PrivateKey.fromString(env.devKeys[env.identityKey])
+        .toPublicKey()
+        .toAddress(setup.chain === 'main' ? 'mainnet' : 'testnet')
+
+      expect(address).toBeDefined()
+      expect(typeof address).toBe('string')
+      expect(address.length).toBeGreaterThan(20)
+
+      // Test balance retrieval (may be 0 if no funds)
+      try {
+        const balance = await setup.wallet.balance()
+        expect(typeof balance).toBe('number')
+        expect(balance).toBeGreaterThanOrEqual(0)
+      } catch (err: any) {
+        // Balance might fail if services not configured, but that's expected
+      }
+    }, 10000)
+
+    test('waitForAuthentication - should resolve immediately for base wallet', async () => {
+      const result = await setup.wallet.waitForAuthentication({})
+      expect(result).toBeDefined()
+      expect(result.authenticated).toBeDefined()
+      // Base wallet resolves immediately
+    }, 10000)
+
+    test('isAuthenticated - should check if wallet is authenticated', async () => {
+      const result = await setup.wallet.isAuthenticated({})
+      expect(result).toBeDefined()
+      expect(result.authenticated).toBeDefined()
+      expect(typeof result.authenticated).toBe('boolean')
+    }, 10000)
+
+    test('getNetwork - should return the network information', async () => {
+      const result = await setup.wallet.getNetwork({})
+      expect(result).toBeDefined()
+      expect(result.network).toBeDefined()
+      expect(['main', 'test', 'testnet']).toContain(result.network)
+    }, 10000)
+
+    test('getVersion - should return wallet version information', async () => {
+      const result = await setup.wallet.getVersion({})
+      expect(result).toBeDefined()
+      expect(result.version).toBeDefined()
+      expect(typeof result.version).toBe('string')
+    }, 10000)
+  })
+
+  // ============================================================================
+  // Keys and Signatures
+  // ============================================================================
+
+  describe('Keys and Signatures', () => {
+    test('getPublicKey - should derive protocol-specific public key', async () => {
+      const result = await setup.wallet.getPublicKey({
+        identityKey: true,
+        protocolID: [0, 'testprotocol'],
+        keyID: '1',
+        counterparty: 'self'
+      })
+
+      expect(result).toBeDefined()
+      expect(result.publicKey).toBeDefined()
+      expect(typeof result.publicKey).toBe('string')
+      expect(result.publicKey.length).toBeGreaterThan(60) // Public key length
+    }, 10000)
+
+    test('createSignature - should sign data with wallet keys', async () => {
+      const testMessage = 'Hello, BSV!'
+      const data = Array.from(Buffer.from(testMessage))
+
+      const result = await setup.wallet.createSignature({
+        data,
+        protocolID: [0, 'testprotocol'],
+        keyID: '1',
+        counterparty: 'self'
+      })
+      expect(result).toBeDefined()
+      expect(result.signature).toBeDefined()
+    }, 10000)
+
+    test('verifySignature - should create and verify signature round-trip', async () => {
+      const testMessage = 'Test signature verification'
+      const data = Array.from(Buffer.from(testMessage))
+
+      // Create signature
+      const createResult = await setup.wallet.createSignature({
+        data,
+        protocolID: [0, 'testprotocol'],
+        keyID: '1',
+        counterparty: 'self'
+      })
+
+      // Verify signature
+      const verifyResult = await setup.wallet.verifySignature({
+        data,
+        signature: createResult.signature,
+        protocolID: [0, 'testprotocol'],
+        keyID: '1',
+        counterparty: 'self'
+      })
+
+      expect(verifyResult).toBeDefined()
+      expect(verifyResult.valid).toBe(true)
+    }, 10000)
+
+    test('revealCounterpartyKeyLinkage - should reveal counterparty key linkage', async () => {
+      try {
+        const result = await setup.wallet.revealCounterpartyKeyLinkage({
+          counterparty: 'self',
+          verifier: '02' + 'a'.repeat(64), // demo verifier pubkey
+          privilegedReason: 'Demo'
+        })
+
+        expect(result).toBeDefined()
+        expect(result.prover).toBeDefined()
+        expect(result.counterparty).toBeDefined()
+      } catch (err: any) {
+        // This might fail in test environments, which is expected
+      }
+    }, 10000)
+
+    test('revealSpecificKeyLinkage - should reveal specific key linkage', async () => {
+      try {
+        const result = await setup.wallet.revealSpecificKeyLinkage({
+          counterparty: 'self',
+          verifier: '02' + 'a'.repeat(64), // demo verifier pubkey
+          protocolID: [0, 'testprotocol'],
+          keyID: '1',
+          privilegedReason: 'Demo'
+        })
+
+        expect(result).toBeDefined()
+        expect(result.prover).toBeDefined()
+        expect(result.counterparty).toBeDefined()
+        expect(result.protocolID).toBeDefined()
+        expect(result.keyID).toBeDefined()
+      } catch (err: any) {
+        // This might fail in test environments, which is expected
+      }
+    }, 10000)
+  })
+
+  // ============================================================================
+  // Crypto Operations
+  // ============================================================================
+
+  describe('Crypto Operations', () => {
+    test('createHmac - should generate HMAC for message', async () => {
+      const testMessage = 'Hello, HMAC!'
+      const data = Array.from(Buffer.from(testMessage))
+
+      const result = await setup.wallet.createHmac({
+        data,
+        protocolID: [0, 'testprotocol'],
+        keyID: '1',
+        counterparty: 'self'
+      })
+
+      expect(result).toBeDefined()
+      expect(result.hmac).toBeDefined()
+    }, 10000)
+
+    test('verifyHmac - should create and verify HMAC round-trip', async () => {
+      const testMessage = 'Test HMAC verification'
+      const data = Array.from(Buffer.from(testMessage))
+
+      // Create HMAC
+      const createResult = await setup.wallet.createHmac({
+        data,
+        protocolID: [0, 'testprotocol'],
+        keyID: '1',
+        counterparty: 'self'
+      })
+
+      // Verify HMAC
+      const verifyResult = await setup.wallet.verifyHmac({
+        data,
+        hmac: createResult.hmac,
+        protocolID: [0, 'testprotocol'],
+        keyID: '1',
+        counterparty: 'self'
+      })
+
+      expect(verifyResult).toBeDefined()
+      expect(verifyResult.valid).toBe(true)
+    }, 10000)
+
+    test('encrypt/decrypt - should encrypt data and decrypt it back', async () => {
+      const testMessage = 'Secret Message!'
+      const plaintext = Array.from(Buffer.from(testMessage))
+
+      // Encrypt
+      const encryptResult = await setup.wallet.encrypt({
+        plaintext,
+        protocolID: [0, 'encryption'],
+        keyID: '1',
+        counterparty: 'self'
+      })
+
+      expect(encryptResult).toBeDefined()
+      expect(encryptResult.ciphertext).toBeDefined()
+
+      // Decrypt
+      const decryptResult = await setup.wallet.decrypt({
+        ciphertext: encryptResult.ciphertext,
+        protocolID: [0, 'encryption'],
+        keyID: '1',
+        counterparty: 'self'
+      })
+
+      expect(decryptResult).toBeDefined()
+      expect(decryptResult.plaintext).toBeDefined()
+      expect(Array.isArray(decryptResult.plaintext)).toBe(true)
+
+      // Verify decrypted message matches original
+      const decrypted = Buffer.from(decryptResult.plaintext).toString()
+      expect(decrypted).toBe(testMessage)
+    }, 10000)
+  })
+
+  // ============================================================================
+  // Actions
+  // ============================================================================
+
+  describe('Actions', () => {
+    test('createAction - should create OP_RETURN transaction (noSend + abort)', async () => {
+      // Check balance first - need at least 10 sats to safely run this test
+      const balance = await setup.wallet.balance()
+      if (balance < 10) return
+
+      try {
+        const message = 'Hello, World! - Test Action'
+        const messageBytes = Buffer.from(message)
+        const hexData = messageBytes.toString('hex')
+        const length = messageBytes.length
+        const lockingScript = `006a${length.toString(16).padStart(2, '0')}${hexData}`
+
+        // Use noSend: true to create tx without broadcasting
+        const action = await setup.wallet.createAction({
+          description: `Store message: ${message}`,
+          outputs: [
+            {
+              lockingScript,
+              satoshis: 0,
+              outputDescription: 'Message output',
+              basket: 'opreturn',
+              tags: ['demo', 'opreturn']
+            }
+          ],
+          labels: ['demo:create_action'],
+          options: {
+            noSend: true // Don't broadcast - just create the transaction
+          }
+        })
+
+        expect(action).toBeDefined()
+
+        // With noSend, wallet may return signableTransaction (needs signing) or txid (auto-signed)
+        if (action.signableTransaction?.reference) {
+          // Can abort - add to cleanup list and abort immediately
+          pendingAborts.push(action.signableTransaction.reference)
+          const abortResult = await setup.wallet.abortAction({
+            reference: action.signableTransaction.reference
+          })
+          expect(abortResult.aborted).toBe(true)
+          // Remove from pending since we aborted it
+          pendingAborts.pop()
+        }
+        // else: auto-signed nosend tx - cleanup handles it
+      } catch (err: any) {
+        if (
+          err.message.includes('Insufficient funds') ||
+          err.message.includes('insufficient')
+        )
+          return
+        throw err
+      }
+    }, 15000)
+
+    test('createAction - verify action result structure', async () => {
+      // Check balance first
+      const balance = await setup.wallet.balance()
+      if (balance < 10) return
+
+      try {
+        const message = 'Structure Test'
+        const messageBytes = Buffer.from(message)
+        const hexData = messageBytes.toString('hex')
+        const length = messageBytes.length
+        const lockingScript = `006a${length.toString(16).padStart(2, '0')}${hexData}`
+
+        // Create action with noSend to inspect the result structure
+        const action = await setup.wallet.createAction({
+          description: `Structure test: ${message}`,
+          outputs: [
+            {
+              lockingScript,
+              satoshis: 0,
+              outputDescription: 'Test output',
+              basket: 'opreturn',
+              tags: ['test']
+            }
+          ],
+          labels: ['test:structure'],
+          options: {
+            noSend: true
+          }
+        })
+
+        expect(action).toBeDefined()
+
+        // Verify result structure - either signableTransaction or txid
+        if (action.signableTransaction) {
+          expect(action.signableTransaction.reference).toBeDefined()
+          expect(action.signableTransaction.tx).toBeDefined()
+          // Cleanup - abort to release UTXOs
+          await setup.wallet.abortAction({
+            reference: action.signableTransaction.reference
+          })
+        } else if (action.txid) {
+          expect(typeof action.txid).toBe('string')
+          expect(action.txid.length).toBe(64)
+        } else {
+          throw new Error('Expected either signableTransaction or txid')
+        }
+      } catch (err: any) {
+        if (
+          err.message.includes('Insufficient funds') ||
+          err.message.includes('insufficient')
+        )
+          return
+        throw err
+      }
+    }, 15000)
+
+    test('listActions - should list recent wallet actions', async () => {
+      const actions = await setup.wallet.listActions({
+        labels: [],
+        limit: 10,
+        includeLabels: true
+      })
+
+      expect(actions).toBeDefined()
+      expect(actions.actions).toBeDefined()
+      expect(Array.isArray(actions.actions)).toBe(true)
+      expect(actions.actions.length).toBeGreaterThanOrEqual(0)
+    }, 10000)
+
+    test('abortAction - should abort an unsigned action if available', async () => {
+      // Check if there are any unsigned actions we can abort
+      const actions = await setup.wallet.listActions({ labels: [], limit: 20 })
+      const unsignedAction = actions.actions.find(
+        a => a.status === 'unsigned' || a.status === 'nosend'
+      )
+
+      // listActions doesn't return references, so we can only abort
+      // actions we created in the same session with signableTransaction
+      expect(unsignedAction === undefined || unsignedAction.status).toBeTruthy()
+    }, 10000)
+  })
+
+  // ============================================================================
+  // Outputs
+  // ============================================================================
+
+  describe('Outputs', () => {
+    test('listOutputs - should list wallet outputs', async () => {
+      const outputs = await setup.wallet.listOutputs({
+        basket: 'default',
+        limit: 10,
+        offset: 0
+      })
+      expect(outputs).toBeDefined()
+      expect(outputs.outputs).toBeDefined()
+      expect(Array.isArray(outputs.outputs)).toBe(true)
+      expect(typeof outputs.totalOutputs).toBe('number')
+      expect(outputs.totalOutputs).toBeGreaterThanOrEqual(0)
+    }, 10000)
+
+    test('relinquishOutput - should relinquish an output from wallet tracking', async () => {
+      // Use a dummy outpoint since we likely don't have real outputs to relinquish
+      const dummyOutpoint =
+        '0000000000000000000000000000000000000000000000000000000000000000:0'
+
+      try {
+        const result = await setup.wallet.relinquishOutput({
+          basket: 'default',
+          output: dummyOutpoint
+        })
+
+        expect(result).toBeDefined()
+        expect(result.relinquished).toBeDefined()
+      } catch (err: any) {
+        // Expected to fail with dummy outpoint
+        expect(err).toBeDefined()
+      }
+    }, 10000)
+  })
+
+  // ============================================================================
+  // Certificates
+  // ============================================================================
+
+  describe('Certificates', () => {
+    test('acquireCertificate - should attempt to acquire a certificate', async () => {
+      try {
+        const result = await setup.wallet.acquireCertificate({
+          type: Buffer.from('test-certificate').toString('base64'),
+          certifier: setup.identityKey,
+          acquisitionProtocol: 'issuance',
+          certifierUrl: 'http://localhost:8080',
+          fields: {
+            name: 'Test User',
+            email: 'test@example.com'
+          },
+          privilegedReason: 'Demo acquisition'
+        })
+        expect(result).toBeDefined()
+      } catch (err: any) {
+        // Expected to fail in test environment
+        expect(err).toBeDefined()
+      }
+    }, 10000)
+
+    test('listCertificates - should list wallet certificates', async () => {
+      const certs = await setup.wallet.listCertificates({
+        certifiers: [],
+        types: [],
+        limit: 10,
+        offset: 0
+      })
+
+      expect(certs).toBeDefined()
+      expect(certs.certificates).toBeDefined()
+      expect(Array.isArray(certs.certificates)).toBe(true)
+      expect(certs.certificates.length).toBeGreaterThanOrEqual(0)
+      if (certs.certificates.length > 0) {
+        const testCert = certs.certificates.find(
+          c => c.type === 'test-certificate'
+        )
+        if (testCert) {
+          expect(testCert.subject).toBeDefined()
+        }
+      }
+    }, 10000)
+
+    test('relinquishCertificate - should relinquish a certificate', async () => {
+      // First check if we have any certificates to relinquish
+      const certs = await setup.wallet.listCertificates({
+        certifiers: [],
+        types: [],
+        limit: 10,
+        offset: 0
+      })
+
+      if (certs.certificates.length === 0) return
+
+      // Try to relinquish the first certificate
+      const cert = certs.certificates[0]
+
+      try {
+        await setup.wallet.relinquishCertificate({
+          type: cert.type,
+          certifier: cert.certifier || 'self',
+          serialNumber: cert.serialNumber || ''
+        })
+      } catch (err: any) {
+        // Expected to fail in test environment
+        expect(err).toBeDefined()
+      }
+    }, 10000)
+  })
+
+  // ============================================================================
+  // Identity Discovery
+  // ============================================================================
+
+  describe('Identity Discovery', () => {
+    test('discoverByIdentityKey - should discover certificates by identity key', async () => {
+      try {
+        const result = await setup.wallet.discoverByIdentityKey({
+          identityKey: setup.identityKey,
+          limit: 10,
+          offset: 0,
+          seekPermission: true
+        })
+
+        expect(result).toBeDefined()
+        expect(result.certificates).toBeDefined()
+        expect(Array.isArray(result.certificates)).toBe(true)
+      } catch (err: any) {
+        // Expected to fail in test environment
+        expect(err).toBeDefined()
+      }
+    }, 10000)
+
+    test('discoverByAttributes - should discover certificates by attributes', async () => {
+      try {
+        const result = await setup.wallet.discoverByAttributes({
+          attributes: { verified: 'true' },
+          limit: 10,
+          offset: 0
+        })
+
+        expect(result).toBeDefined()
+        expect(result.certificates).toBeDefined()
+        expect(Array.isArray(result.certificates)).toBe(true)
+      } catch (err: any) {
+        // Expected to fail in test environment
+        expect(err).toBeDefined()
+      }
+    }, 10000)
+  })
+
+  // ============================================================================
+  // Transactions
+  // ============================================================================
+
+  describe('Transactions', () => {
+    test('internalizeAction - should internalize an external transaction', async () => {
+      // This is a complex operation that requires an actual external transaction
+      // For testing purposes, we'll try with minimal parameters and expect graceful failure
+      try {
+        const dummyTxHex =
+          '01000000010000000000000000000000000000000000000000000000000000000000000000ffffffff0100ffffffff01000000000000000000000000'
+        const result = await setup.wallet.internalizeAction({
+          tx: Array.from(Buffer.from(dummyTxHex, 'hex')),
+          outputs: [
+            {
+              outputIndex: 0,
+              protocol: 'basket insertion',
+              insertionRemittance: {
+                basket: 'default'
+              }
+            }
+          ],
+          description: 'Test internalization of external transaction'
+        })
+
+        expect(result).toBeDefined()
+      } catch (err: any) {
+        // Expected to fail with dummy data
+        expect(err).toBeDefined()
+      }
+    }, 10000)
+  })
+
+  // ============================================================================
+  // Blockchain Info
+  // ============================================================================
+
+  describe('Blockchain Info', () => {
+    test('getHeight - should fetch current block height', async () => {
+      try {
+        const result = await setup.wallet.getHeight({})
+        expect(result).toBeDefined()
+        expect(result.height).toBeDefined()
+        expect(typeof result.height).toBe('number')
+        expect(result.height).toBeGreaterThan(0)
+      } catch (err: any) {
+        // May fail if Services not configured
+      }
+    }, 10000)
+
+    test('getHeaderForHeight - should fetch header for specific height', async () => {
+      try {
+        const testHeight = 1
+        const result = await setup.wallet.getHeaderForHeight({
+          height: testHeight
+        })
+
+        expect(result).toBeDefined()
+        expect(result.header).toBeDefined()
+        expect(typeof result.header).toBe('string')
+        expect(result.header.length).toBeGreaterThan(100)
+      } catch (err: any) {
+        // May fail if Services not configured
+      }
+    }, 10000)
+  })
+})
diff --git a/src/generateKey.ts b/src/generateKey.ts
new file mode 100644
index 0000000..fb0192e
--- /dev/null
+++ b/src/generateKey.ts
@@ -0,0 +1,69 @@
+import { PrivateKey } from '@bsv/sdk'
+import { runArgv2Function } from './runArgv2Function'
+
+/**
+ * Generate a new BSV testnet private key and address for live testing.
+ *
+ * This utility generates a new private key and displays:
+ * - The private key (for .env file)
+ * - The testnet address (for funding)
+ * - Links to testnet faucets
+ *
+ * After generating, fund the address using a testnet faucet, then run the live tests.
+ *
+ * Usage:
+ * ```bash
+ * npx tsx generateKey
+ * ```
+ *
+ * This will output:
+ * - Private key for .env
+ * - Testnet address for funding
+ * - Faucet links
+ *
+ * @publicbody
+ */
+export async function generateKey() {
+  console.log('🔑 Generating new BSV testnet key for live testing...\n')
+
+  // Generate a new private key
+  const privateKey = PrivateKey.fromRandom()
+  const publicKey = privateKey.toPublicKey()
+
+  // Get testnet address
+  const testnetAddress = publicKey.toAddress('testnet')
+
+  // Get private key as hex
+  const privateKeyHex = privateKey.toString()
+
+  console.log('='.repeat(80))
+  console.log('🔑 NEW TESTNET KEY GENERATED')
+  console.log('='.repeat(80))
+  console.log()
+  console.log('📝 Add this to your .env file:')
+  console.log(`LIVE_PRIVATE_KEY=${privateKeyHex}`)
+  console.log()
+  console.log('💰 Fund this testnet address:')
+  console.log(`${testnetAddress}`)
+  console.log()
+  console.log('🔗 Testnet Faucets:')
+  console.log(
+    '  • MoneyButton Testnet Faucet: https://testnetfaucet.moneybutton.com/'
+  )
+  console.log(
+    '  • Whatsonchain Testnet Faucet: https://faucet.whatsonchain.com/'
+  )
+  console.log(
+    '  • Mempool Testnet Faucet: https://testnet-faucet.mempool.space/'
+  )
+  console.log()
+  console.log('⚠️  WARNING: This private key is for TESTNET only!')
+  console.log('   Never use testnet keys or funds on mainnet!')
+  console.log()
+  console.log('🚀 After funding, run live tests with:')
+  console.log('   npm run test:py:live')
+  console.log()
+  console.log('='.repeat(80))
+}
+
+runArgv2Function(module.exports)
diff --git a/src/internalizeWalletPayment.ts b/src/internalizeWalletPayment.ts
index 0864711..a9f0175 100644
--- a/src/internalizeWalletPayment.ts
+++ b/src/internalizeWalletPayment.ts
@@ -13,6 +13,7 @@ import {
   SetupWallet
 } from '@bsv/wallet-toolbox'
 import { outputBRC29 } from './brc29'
+// @ts-ignore - parseWalletOutpoint import issue
 import { parseWalletOutpoint } from '@bsv/wallet-toolbox/out/src/sdk'
 import { runArgv2Function } from './runArgv2Function'
 
diff --git a/src/janitor.ts b/src/janitor.ts
index 585ff9e..052f6ff 100644
--- a/src/janitor.ts
+++ b/src/janitor.ts
@@ -1,5 +1,6 @@
 import { sdk, Setup } from '@bsv/wallet-toolbox'
 import {
+  // @ts-ignore - parseWalletOutpoint import issue
   parseWalletOutpoint,
   specOpInvalidChange
 } from '@bsv/wallet-toolbox/out/src/sdk'
diff --git a/src/listChange.ts b/src/listChange.ts
index cc6a9d1..4a34800 100644
--- a/src/listChange.ts
+++ b/src/listChange.ts
@@ -1,5 +1,6 @@
 import { Beef } from '@bsv/sdk'
 import { Setup } from '@bsv/wallet-toolbox'
+// @ts-ignore - parseWalletOutpoint import issue
 import { parseWalletOutpoint } from '@bsv/wallet-toolbox/out/src/sdk'
 import { runArgv2Function } from './runArgv2Function'
 
diff --git a/src/walletInfra.ts b/src/walletInfra.ts
new file mode 100644
index 0000000..1b56c88
--- /dev/null
+++ b/src/walletInfra.ts
@@ -0,0 +1,915 @@
+import {
+  Beef,
+  BEEF_V2,
+  InternalizeActionArgs,
+  MerklePath,
+  P2PKH,
+  Script,
+  Transaction
+} from '@bsv/sdk'
+import { PrivateKey } from '@bsv/sdk'
+import { Setup, Services } from '@bsv/wallet-toolbox'
+import { Chain } from '@bsv/wallet-toolbox'
+import { runArgv2Function } from './runArgv2Function'
+import * as readline from 'readline'
+
+/**
+ * Default local wallet-infra endpoint URL.
+ * This matches the default port in wallet-infra's docker-compose setup.
+ */
+const DEFAULT_WALLET_INFRA_URL = 'http://localhost:8080'
+
+/**
+ * Helper to prompt user for input.
+ */
+function prompt(question: string, defaultValue?: string): Promise<string> {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  })
+  const displayQuestion = defaultValue
+    ? `${question} [Enter=${defaultValue}]: `
+    : `${question}: `
+  return new Promise(resolve => {
+    rl.question(displayQuestion, answer => {
+      rl.close()
+      resolve(answer.trim() || defaultValue || '')
+    })
+  })
+}
+
+/**
+ * Build Atomic BEEF from raw transaction hex.
+ *
+ * This helper function takes a raw transaction hex and:
+ * 1. Parses the transaction to get txid
+ * 2. Attempts to fetch merkle proof from Services (if mined)
+ * 3. Builds Atomic BEEF format
+ *
+ * @param rawTxHex Raw transaction hex string
+ * @param chain Network chain ('main' or 'test')
+ * @returns Atomic BEEF binary data and txid
+ */
+async function buildAtomicBeefFromRawTx(
+  rawTxHex: string,
+  chain: Chain
+): Promise<{
+  atomicBeef: number[]
+  txid: string
+}> {
+  console.log(`🔍 Parsing raw transaction (${rawTxHex.length} chars)...`)
+
+  // Parse the raw transaction
+  const tx = Transaction.fromHex(rawTxHex)
+  const txid = tx.id('hex')
+
+  console.log(`✅ Transaction parsed`)
+  console.log(`   TXID: ${txid}`)
+  console.log(`   Inputs: ${tx.inputs.length}, Outputs: ${tx.outputs.length}`)
+
+  // Debug: check inputs
+  for (let i = 0; i < tx.inputs.length; i++) {
+    const input = tx.inputs[i]
+    console.log(
+      `   Input ${i}: ${input.sourceTXID} (vout: ${input.sourceOutputIndex})`
+    )
+  }
+
+  // Create Atomic BEEF
+  const beef = new Beef(BEEF_V2)
+
+  // Try to fetch merkle proof if the transaction is mined
+  try {
+    const services = new Services(chain)
+    console.log(`🔎 Looking up merkle proof for txid: ${txid}...`)
+
+    const merkleResult = await services.getMerklePath(txid)
+    console.log({ merkleResult })
+    if (merkleResult && merkleResult.merklePath) {
+      // Attach merkle path to transaction - mergeTransaction will handle it
+      tx.merklePath = merkleResult.merklePath
+      console.log(
+        `✅ Merkle proof found (height: ${merkleResult.merklePath.blockHeight})`
+      )
+    } else {
+      console.log(`⚠️  No merkle proof found - transaction may be unconfirmed`)
+    }
+  } catch (error: any) {
+    console.log(`⚠️  Failed to fetch merkle proof: ${error.message}`)
+  }
+
+  // Add transaction to BEEF
+  beef.mergeTransaction(tx)
+
+  // Use toBinaryAtomic() to create proper Atomic BEEF format
+  const atomicBeef = beef.toBinaryAtomic(txid)
+
+  console.log(`✅ Atomic BEEF built successfully`)
+  console.log(`   Size: ${atomicBeef.length} bytes`)
+
+  return { atomicBeef, txid }
+}
+
+/**
+ * Internalize a raw transaction hex into wallet-infra storage.
+ *
+ * This function takes a raw transaction hex, builds Atomic BEEF (with merkle proof if mined),
+ * and imports the specified output into the wallet storage using the basket insertion protocol.
+ *
+ * Run: `npx tsx walletInfra internalizeRawTx`
+ *
+ * @publicbody
+ */
+export async function internalizeRawTx(): Promise<void> {
+  const endpointUrl = process.env.WALLET_INFRA_URL || DEFAULT_WALLET_INFRA_URL
+
+  console.log(`
+================================================================================
+🏗️  Internalize Raw Transaction
+================================================================================
+`)
+
+  try {
+    // Get raw transaction hex
+    const rawTxHex =
+      process.env.RAW_TX ||
+      (await prompt(
+        'Raw transaction hex',
+        '010000000103cb9012f93af9225957a2840b0850b5d438042a64720ca5f2bfa3d19014f627000000006b483045022100ac09a089f417587f2e8e74c66e9111fed55523df3b9e522e075d3744a0480f6902206a9e0c2b9e9fd528b0f910e774df91b209eb5f327f6ce7e836a24e0052ce828e412102ecc1a2735aa3a5aab36b6d215cd48f764c7552851d2d3ffe800ac08551ad1338ffffffff02e8030000000000001976a9140d227bc5e21d6c4bde15776cf767e646f78f1aa488ac90810100000000001976a9141cb6822fa326ce07ed55b10762d94db77272376d88ac00000000'
+      ))
+
+    // Get output index to internalize
+    const outputIndexStr =
+      process.env.OUTPUT_INDEX ||
+      (await prompt('Output index to internalize', '0'))
+    const outputIndex = parseInt(outputIndexStr, 10)
+
+    if (isNaN(outputIndex) || outputIndex < 0) {
+      console.log(`❌ Invalid output index: ${outputIndexStr}`)
+      return
+    }
+
+    // Read the secrets from .env file created by 'makeEnv'
+    const env = Setup.getEnv('test')
+
+    // Create a wallet client connected to your local wallet-infra server
+    const setup = await Setup.createWalletClient({
+      env,
+      rootKeyHex: env.devKeys[env.identityKey],
+      endpointUrl
+    })
+
+    console.log(`✅ Connected successfully!`)
+    console.log(`   Identity Key: ${setup.identityKey}`)
+    console.log(`   Chain: ${setup.chain}`)
+    console.log(`   Endpoint: ${setup.endpointUrl}`)
+    console.log()
+
+    // Build Atomic BEEF from raw transaction
+    const { atomicBeef, txid } = await buildAtomicBeefFromRawTx(
+      rawTxHex,
+      setup.chain
+    )
+    const outpoint = `${txid}.${outputIndex}`
+
+    console.log(`\n📍 Internalizing output: ${outpoint}`)
+    console.log()
+
+    // Internalize the transaction output using basket insertion protocol
+    // NOTE: 'basket insertion' creates custom outputs that don't count toward balance!
+    // Use 'external-utxos' basket to track these for later spending.
+    const internalizeArgs: InternalizeActionArgs = {
+      tx: atomicBeef,
+      outputs: [
+        {
+          outputIndex,
+          protocol: 'basket insertion',
+          insertionRemittance: {
+            basket: 'external-utxos',
+            tags: ['wallet-infra-example', 'internalized', 'external-funding']
+          }
+        }
+      ],
+      description: `Internalized output ${outpoint}`,
+      labels: [`txid:${txid}`, 'internalized']
+    }
+
+    console.log(`🚀 Internalizing transaction...`)
+    const result = await setup.wallet.internalizeAction(internalizeArgs)
+
+    console.log(`
+================================================================================
+✅ Transaction Internalized!
+================================================================================
+   TXID: ${txid}
+   Outpoint: ${outpoint}
+   Status: Transaction accepted
+
+   View on explorer:
+   https://${setup.chain === 'main' ? '' : 'test.'}whatsonchain.com/tx/${txid}
+================================================================================
+`)
+  } catch (error: any) {
+    console.error(`
+❌ Internalization failed!
+
+   Error: ${error.message}
+
+   Possible issues:
+   1. Is wallet-infra running? Start with: docker-compose up
+   2. Is the raw transaction hex valid?
+   3. Is the output index correct?
+   4. Does this output belong to your wallet?
+
+================================================================================
+`)
+    process.exit(1)
+  }
+}
+
+/**
+ * Main entry point - checks balance and shows receive address if empty.
+ *
+ * Run: `npx tsx walletInfra`
+ *
+ * @publicbody
+ */
+export async function walletInfra(): Promise<void> {
+  const endpointUrl = process.env.WALLET_INFRA_URL || DEFAULT_WALLET_INFRA_URL
+
+  console.log(`
+================================================================================
+🔗 Connecting to wallet-infra at: ${endpointUrl}
+================================================================================
+`)
+
+  try {
+    // Read the secrets from .env file created by 'makeEnv'
+    const env = Setup.getEnv('test')
+
+    // Create a wallet client connected to your local wallet-infra server
+    const setup = await Setup.createWalletClient({
+      env,
+      rootKeyHex: env.devKeys[env.identityKey],
+      endpointUrl
+    })
+
+    console.log(`✅ Connected successfully!`)
+    console.log(`   Identity Key: ${setup.identityKey}`)
+    console.log(`   Chain: ${setup.chain}`)
+    console.log(`   Endpoint: ${setup.endpointUrl}`)
+
+    // Get the wallet balance
+    const balance = await setup.wallet.balance()
+
+    console.log(`
+================================================================================
+💰 Wallet Balance: ${balance} satoshis
+================================================================================
+`)
+
+    // If balance is zero, show how to fund the wallet
+    if (balance === 0) {
+      // Use correct address prefix based on chain (testnet vs mainnet)
+      const addressPrefix = setup.chain === 'main' ? 'mainnet' : 'testnet'
+      const address = PrivateKey.fromString(env.devKeys[env.identityKey])
+        .toPublicKey()
+        .toAddress(addressPrefix)
+
+      console.log(`
+⚠️  Your wallet has no funds!
+
+To get started, send testnet BSV to your wallet:
+
+   📍 Your Testnet Address:
+   ${address}
+
+   🚰 Get free testnet coins from:
+   https://scrypt.io/faucet/
+
+   📋 Steps:
+   1. Copy your address above
+   2. Visit the faucet URL
+   3. Paste your address and request coins
+   4. Wait for confirmation (~10 seconds)
+   5. Run this command again to check your balance
+
+   🔍 View on explorer:
+   https://${setup.chain === 'main' ? '' : 'test.'}whatsonchain.com/address/${address}
+
+================================================================================
+`)
+    } else {
+      // Show outputs summary
+      const outputs = await setup.wallet.listOutputs({
+        basket: 'default',
+        limit: 5
+      })
+      console.log(`📦 Outputs in 'default' basket: ${outputs.totalOutputs}`)
+
+      if (outputs.outputs.length > 0) {
+        console.log(`\n   Recent outputs:`)
+        for (const output of outputs.outputs) {
+          console.log(`   • ${output.outpoint}: ${output.satoshis} sats`)
+        }
+      }
+      console.log('')
+    }
+  } catch (error: any) {
+    console.error(`
+❌ Connection failed!
+
+   Error: ${error.message}
+
+   Possible issues:
+   1. Is wallet-infra running? Start with: docker-compose up
+   2. Is the URL correct? Currently: ${endpointUrl}
+   3. Do you have a .env file? Generate with: npx tsx makeEnv > .env
+
+================================================================================
+`)
+    process.exit(1)
+  }
+}
+
+/**
+ * Connect to wallet-infra without requiring a .env file.
+ *
+ * This is useful for quick testing or when you want to manage keys differently.
+ *
+ * Run: `npx tsx walletInfra walletInfraNoEnv`
+ *
+ * @publicbody
+ */
+export async function walletInfraNoEnv(): Promise<void> {
+  const endpointUrl = process.env.WALLET_INFRA_URL || DEFAULT_WALLET_INFRA_URL
+
+  // Generate a new random key for testing, or use your own
+  const rootKey = process.env.ROOT_KEY_HEX || PrivateKey.fromRandom().toHex()
+
+  console.log(`
+================================================================================
+🔗 Connecting to wallet-infra (no .env) at: ${endpointUrl}
+================================================================================
+`)
+
+  // Create wallet client without .env file
+  const wallet = await Setup.createWalletClientNoEnv({
+    chain: 'test',
+    rootKeyHex: rootKey,
+    storageUrl: endpointUrl
+  })
+
+  const identityKey = (await wallet.getPublicKey({ identityKey: true }))
+    .publicKey
+
+  console.log(`✅ Connected successfully!`)
+  console.log(`   Identity Key: ${identityKey}`)
+
+  // Get the wallet balance
+  const balance = await wallet.balance()
+
+  console.log(`
+================================================================================
+💰 Wallet Balance: ${balance} satoshis
+================================================================================
+`)
+
+  // List any outputs in the default basket
+  const outputs = await wallet.listOutputs({ basket: 'default', limit: 10 })
+  console.log(`📦 Outputs in 'default' basket: ${outputs.totalOutputs}`)
+
+  if (outputs.outputs.length > 0) {
+    console.log(`\n   Recent outputs:`)
+    for (const output of outputs.outputs.slice(0, 5)) {
+      console.log(`   - ${output.outpoint}: ${output.satoshis} sats`)
+    }
+  }
+}
+
+/**
+ * List actions from your wallet-infra connected wallet.
+ *
+ * Run: `npx tsx walletInfra walletInfraListActions`
+ *
+ * @publicbody
+ */
+export async function walletInfraListActions(): Promise<void> {
+  const endpointUrl = process.env.WALLET_INFRA_URL || DEFAULT_WALLET_INFRA_URL
+  const env = Setup.getEnv('test')
+
+  console.log(`
+================================================================================
+📋 Listing Actions from wallet-infra at: ${endpointUrl}
+================================================================================
+`)
+
+  const setup = await Setup.createWalletClient({
+    env,
+    rootKeyHex: env.devKeys[env.identityKey],
+    endpointUrl
+  })
+
+  // List recent actions
+  const actions = await setup.wallet.listActions({
+    labels: [],
+    limit: 10,
+    includeLabels: true,
+    includeInputs: true,
+    includeOutputs: true
+  })
+
+  console.log(`\n📜 Total actions: ${actions.totalActions}`)
+
+  if (actions.actions.length > 0) {
+    console.log(`\n   Recent actions:`)
+    for (const action of actions.actions) {
+      console.log(`
+   ─────────────────────────────────────────
+   TXID: ${action.txid}
+   Description: ${action.description}
+   Status: ${action.status}
+   Satoshis: ${action.satoshis}
+   Labels: ${action.labels?.join(', ') || 'none'}
+   Version: ${action.version}`)
+    }
+  } else {
+    console.log(`\n   No actions found.`)
+  }
+}
+
+/**
+ * Create a simple OP_RETURN data transaction using wallet-infra.
+ *
+ * Run: `npx tsx walletInfra walletInfraCreateData`
+ *
+ * @publicbody
+ */
+export async function walletInfraCreateData(): Promise<void> {
+  const endpointUrl = process.env.WALLET_INFRA_URL || DEFAULT_WALLET_INFRA_URL
+  const env = Setup.getEnv('test')
+
+  console.log(`
+================================================================================
+📝 Creating Data Transaction via wallet-infra at: ${endpointUrl}
+================================================================================
+`)
+
+  const setup = await Setup.createWalletClient({
+    env,
+    rootKeyHex: env.devKeys[env.identityKey],
+    endpointUrl
+  })
+
+  // Check balance first
+  const balance = await setup.wallet.balance()
+  console.log(`\n💰 Current balance: ${balance} satoshis`)
+
+  if (balance < 100) {
+    console.log(`\n⚠️  Insufficient balance. Please fund your wallet first.`)
+    console.log(
+      `   Your address: ${(await setup.wallet.getPublicKey({ identityKey: true })).publicKey}`
+    )
+    return
+  }
+
+  // Create a simple OP_RETURN transaction with embedded data
+  const message = `Hello from wallet-infra! Timestamp: ${new Date().toISOString()}`
+  const dataHex = Buffer.from(message).toString('hex')
+
+  // OP_FALSE OP_RETURN <data>
+  const opReturnScript = `006a${(dataHex.length / 2).toString(16).padStart(2, '0')}${dataHex}`
+
+  const result = await setup.wallet.createAction({
+    description: 'wallet-infra data transaction example',
+    outputs: [
+      {
+        lockingScript: opReturnScript,
+        satoshis: 0,
+        outputDescription: 'OP_RETURN data'
+      }
+    ],
+    labels: ['wallet-infra-example', 'data'],
+    options: {
+      acceptDelayedBroadcast: false
+    }
+  })
+
+  console.log(`
+================================================================================
+✅ Transaction Created!
+================================================================================
+   TXID: ${result.txid}
+   Message: "${message}"
+   
+   View on explorer:
+   https://test.whatsonchain.com/tx/${result.txid}
+================================================================================
+`)
+}
+
+/**
+ * Send P2PKH payment using wallet-infra.
+ *
+ * Run: `npx tsx walletInfra walletInfraSendP2PKH`
+ *
+ * @publicbody
+ */
+export async function walletInfraSendP2PKH(): Promise<void> {
+  const endpointUrl = process.env.WALLET_INFRA_URL || DEFAULT_WALLET_INFRA_URL
+  const env = Setup.getEnv('test')
+
+  // Get recipient address from environment or use identity key 2
+  const recipientAddress = process.env.RECIPIENT_ADDRESS
+  const satoshisToSend = parseInt(process.env.SATOSHIS_TO_SEND || '100', 10)
+
+  console.log(`
+================================================================================
+💸 Sending P2PKH Payment via wallet-infra at: ${endpointUrl}
+================================================================================
+`)
+
+  const setup = await Setup.createWalletClient({
+    env,
+    rootKeyHex: env.devKeys[env.identityKey],
+    endpointUrl
+  })
+
+  // Check balance first
+  const balance = await setup.wallet.balance()
+  console.log(`\n💰 Current balance: ${balance} satoshis`)
+
+  if (balance < satoshisToSend + 100) {
+    // Need extra for fees
+    console.log(`\n⚠️  Insufficient balance to send ${satoshisToSend} sats.`)
+    return
+  }
+
+  // If no recipient provided, create self-payment for testing
+  let toAddress: string
+  const addressPrefix = setup.chain === 'main' ? 'mainnet' : 'testnet'
+  if (recipientAddress) {
+    toAddress = recipientAddress
+  } else {
+    // Send to identity key 2 for testing
+    toAddress = PrivateKey.fromString(env.devKeys[env.identityKey2])
+      .toPublicKey()
+      .toAddress(addressPrefix)
+    console.log(
+      `\n📍 No RECIPIENT_ADDRESS set, sending to identity key 2: ${toAddress}`
+    )
+  }
+
+  // Create P2PKH output
+  const lockingScript = Setup.getLockP2PKH(toAddress).toHex()
+
+  const result = await setup.wallet.createAction({
+    description: `P2PKH payment: ${satoshisToSend} sats`,
+    outputs: [
+      {
+        lockingScript,
+        satoshis: satoshisToSend,
+        outputDescription: `P2PKH to ${toAddress}`
+      }
+    ],
+    labels: ['wallet-infra-example', 'p2pkh'],
+    options: {
+      acceptDelayedBroadcast: false,
+      randomizeOutputs: false
+    }
+  })
+
+  console.log(`
+================================================================================
+✅ Payment Sent!
+================================================================================
+   TXID: ${result.txid}
+   Amount: ${satoshisToSend} satoshis
+   To: ${toAddress}
+   
+   View on explorer:
+   https://test.whatsonchain.com/tx/${result.txid}
+================================================================================
+`)
+}
+
+/**
+ * Test transaction parsing and BEEF building without wallet-infra connection.
+ *
+ * Run: `npx tsx walletInfra testParseRawTx`
+ *
+ * @publicbody
+ */
+export async function testParseRawTx(): Promise<void> {
+  console.log(`
+================================================================================
+🧪 Test Raw Transaction Parsing
+================================================================================
+`)
+
+  // Get raw transaction hex
+  const rawTxHex =
+    process.env.RAW_TX ||
+    (await prompt(
+      'Raw transaction hex',
+      '010000000103cb9012f93af9225957a2840b0850b5d438042a64720ca5f2bfa3d19014f627000000006b483045022100ac09a089f417587f2e8e74c66e9111fed55523df3b9e522e075d3744a0480f6902206a9e0c2b9e9fd528b0f910e774df91b209eb5f327f6ce7e836a24e0052ce828e412102ecc1a2735aa3a5aab36b6d215cd48f764c7552851d2d3ffe800ac08551ad1338ffffffff02e8030000000000001976a9140d227bc5e21d6c4bde15776cf767e646f78f1aa488ac90810100000000001976a9141cb6822fa326ce07ed55b10762d94db77272376d88ac00000000'
+    ))
+
+  try {
+    // Build Atomic BEEF from raw transaction
+    const { atomicBeef, txid } = await buildAtomicBeefFromRawTx(
+      rawTxHex,
+      'test'
+    )
+
+    console.log(`
+================================================================================
+✅ Transaction Parsed Successfully!
+================================================================================
+   TXID: ${txid}
+   Atomic BEEF Size: ${atomicBeef.length} bytes
+
+   To internalize this transaction into wallet-infra:
+   1. Start wallet-infra: docker-compose up
+   2. Run: npx tsx walletInfra internalizeRawTx
+================================================================================
+`)
+  } catch (error: any) {
+    console.error(`
+❌ Transaction parsing failed!
+
+   Error: ${error.message}
+
+   Possible issues:
+   1. Is the raw transaction hex valid?
+   2. Check the hex format (should be 64 hex characters per byte)
+
+================================================================================
+`)
+    process.exit(1)
+  }
+}
+
+/**
+ * Display wallet info and receive address for funding from faucet.
+ *
+ * Run: `npx tsx walletInfra walletInfraReceive`
+ *
+ * @publicbody
+ */
+export async function walletInfraReceive(): Promise<void> {
+  const endpointUrl = process.env.WALLET_INFRA_URL || DEFAULT_WALLET_INFRA_URL
+  const env = Setup.getEnv('test')
+
+  console.log(`
+================================================================================
+📬 Wallet Receive Address (wallet-infra: ${endpointUrl})
+================================================================================
+`)
+
+  const setup = await Setup.createWalletClient({
+    env,
+    rootKeyHex: env.devKeys[env.identityKey],
+    endpointUrl
+  })
+
+  // Get identity key for P2PKH address - use correct prefix based on chain
+  const identityKey = setup.identityKey
+  const addressPrefix = setup.chain === 'main' ? 'mainnet' : 'testnet'
+  const address = PrivateKey.fromString(env.devKeys[env.identityKey])
+    .toPublicKey()
+    .toAddress(addressPrefix)
+
+  const balance = await setup.wallet.balance()
+
+  console.log(`
+   Identity Key: ${identityKey}
+   
+   📍 Receive Address (P2PKH):
+   ${address}
+   
+   💰 Current Balance: ${balance} satoshis
+   
+   🚰 Get testnet coins from faucet:
+   https://scrypt.io/faucet/
+   
+   Then internalize the transaction using the internalize example.
+================================================================================
+`)
+}
+
+/**
+ * Fund wallet from an external P2PKH output (like from a faucet).
+ *
+ * This is the CORRECT way to add external funds to your wallet. It:
+ * 1. Takes a raw transaction with an output locked to your wallet's address
+ * 2. Spends that output, creating proper wallet change that counts toward balance
+ *
+ * IMPORTANT: The output must be a P2PKH locked to your wallet's identity key address.
+ *
+ * Run: `RAW_TX="hex" OUTPUT_INDEX="0" WALLET_INFRA_URL=http://localhost:8080 npx tsx walletInfra fundFromExternal`
+ *
+ * @publicbody
+ */
+export async function fundFromExternal(): Promise<void> {
+  const endpointUrl = process.env.WALLET_INFRA_URL || DEFAULT_WALLET_INFRA_URL
+  const env = Setup.getEnv('test')
+
+  console.log(`
+================================================================================
+💰 Fund Wallet from External P2PKH Output
+================================================================================
+
+This function takes an external P2PKH output (like from a faucet) and converts
+it to proper wallet change that counts toward your balance.
+
+NOTE: Do NOT use 'internalizeRawTx' for funding - that creates custom outputs
+      that don't count toward balance. Use this function instead!
+`)
+
+  const setup = await Setup.createWalletClient({
+    env,
+    rootKeyHex: env.devKeys[env.identityKey],
+    endpointUrl
+  })
+
+  console.log(`✅ Connected successfully!`)
+  console.log(`   Identity Key: ${setup.identityKey}`)
+  console.log(`   Chain: ${setup.chain}`)
+
+  // Get the wallet's identity key and address
+  const addressPrefix = setup.chain === 'main' ? 'mainnet' : 'testnet'
+  const identityPrivKey = PrivateKey.fromString(env.devKeys[env.identityKey])
+  const walletAddress = identityPrivKey.toPublicKey().toAddress(addressPrefix)
+  const walletPubKeyHash = Buffer.from(
+    identityPrivKey.toPublicKey().toHash()
+  ).toString('hex')
+
+  console.log(`   Your wallet address: ${walletAddress}`)
+  console.log()
+
+  // Get raw transaction hex
+  const rawTxHex =
+    process.env.RAW_TX ||
+    (await prompt('Raw transaction hex containing the output to spend', ''))
+
+  if (!rawTxHex) {
+    console.log(`❌ No raw transaction provided.`)
+    return
+  }
+
+  // Get output index
+  const outputIndexStr =
+    process.env.OUTPUT_INDEX || (await prompt('Output index to spend', '0'))
+  const outputIndex = parseInt(outputIndexStr, 10)
+
+  // Parse the transaction
+  const tx = Transaction.fromHex(rawTxHex)
+  const txid = tx.id('hex')
+
+  if (outputIndex < 0 || outputIndex >= tx.outputs.length) {
+    console.log(
+      `❌ Invalid output index: ${outputIndex}. Transaction has ${tx.outputs.length} outputs.`
+    )
+    return
+  }
+
+  const sourceOutput = tx.outputs[outputIndex]
+  const outpoint = `${txid}.${outputIndex}`
+
+  console.log(`🔍 Analyzing output: ${outpoint}`)
+  console.log(`   Satoshis: ${sourceOutput.satoshis}`)
+
+  // Verify this output belongs to the wallet
+  const outputScript = sourceOutput.lockingScript.toHex()
+  const outputPubKeyHash = outputScript.slice(6, 46) // Extract hash from P2PKH script
+
+  if (outputPubKeyHash !== walletPubKeyHash) {
+    console.log(`
+❌ This output does NOT belong to your wallet!
+
+   Output locked to: ${outputPubKeyHash}
+   Your wallet hash:  ${walletPubKeyHash}
+
+   The output must be a P2PKH locked to your wallet's address: ${walletAddress}
+`)
+    return
+  }
+
+  console.log(`✅ Output belongs to your wallet`)
+  console.log()
+
+  // Build BEEF for the input transaction
+  console.log(`🔎 Looking up merkle proof for input transaction...`)
+  const { atomicBeef } = await buildAtomicBeefFromRawTx(rawTxHex, setup.chain)
+
+  console.log(`
+🔄 Creating funding transaction...
+   This will spend the external output and route funds to your wallet as change.
+`)
+
+  try {
+    // Create simple OP_RETURN output (marker for the funding tx)
+    const message = `Fund: ${new Date().toISOString()}`
+    const dataHex = Buffer.from(message).toString('hex')
+    const opReturnScript = `006a${(dataHex.length / 2).toString(16).padStart(2, '0')}${dataHex}`
+
+    // Create action with the external output as input
+    const result = await setup.wallet.createAction({
+      description: `Fund wallet from external: ${outpoint}`,
+      inputBEEF: atomicBeef,
+      inputs: [
+        {
+          outpoint,
+          unlockingScriptLength: 108, // Standard P2PKH unlocking script
+          inputDescription: 'External P2PKH funding'
+        }
+      ],
+      outputs: [
+        {
+          lockingScript: opReturnScript,
+          satoshis: 0,
+          outputDescription: 'Funding marker'
+        }
+      ],
+      labels: ['wallet-funding', 'external-p2pkh'],
+      options: {
+        acceptDelayedBroadcast: false
+      }
+    })
+
+    if (result.signableTransaction) {
+      console.log(`📝 Signing transaction...`)
+
+      // Parse the signable transaction
+      const signableTx = Transaction.fromBEEF(result.signableTransaction.tx)
+
+      // Create P2PKH unlocker and sign
+      const unlockingScript = await new P2PKH()
+        .unlock(
+          identityPrivKey,
+          'all',
+          false,
+          sourceOutput.satoshis,
+          sourceOutput.lockingScript
+        )
+        .sign(signableTx, 0)
+
+      const signResult = await setup.wallet.signAction({
+        reference: result.signableTransaction.reference,
+        spends: {
+          0: {
+            unlockingScript: unlockingScript.toHex()
+          }
+        },
+        options: { acceptDelayedBroadcast: false }
+      })
+
+      // Get new balance
+      const newBalance = await setup.wallet.balance()
+
+      console.log(`
+================================================================================
+✅ Wallet Funded Successfully!
+================================================================================
+   Source Output: ${outpoint}
+   Amount: ${sourceOutput.satoshis} satoshis (minus fees)
+   Funding TX: ${signResult.txid}
+   
+   New Balance: ${newBalance} satoshis
+   
+   View on explorer:
+   https://${setup.chain === 'main' ? '' : 'test.'}whatsonchain.com/tx/${signResult.txid}
+================================================================================
+`)
+    } else if (result.txid) {
+      const newBalance = await setup.wallet.balance()
+      console.log(`
+================================================================================
+✅ Wallet Funded!
+================================================================================
+   TXID: ${result.txid}
+   New Balance: ${newBalance} satoshis
+   
+   View on explorer:
+   https://${setup.chain === 'main' ? '' : 'test.'}whatsonchain.com/tx/${result.txid}
+================================================================================
+`)
+    }
+  } catch (error: any) {
+    console.error(`
+❌ Funding failed!
+
+   Error: ${error.message}
+
+   Common issues:
+   1. The output may already be spent on-chain
+   2. The transaction may not be confirmed yet
+   3. Network connectivity issues
+
+================================================================================
+`)
+  }
+}
+
+runArgv2Function(module.exports)
diff --git a/tmp_createaction.ts b/tmp_createaction.ts
new file mode 100644
index 0000000..7053585
--- /dev/null
+++ b/tmp_createaction.ts
@@ -0,0 +1,109 @@
+
+      expect(outputs).toBeDefined()
+      expect(outputs.outputs).toBeDefined()
+      expect(Array.isArray(outputs.outputs)).toBe(true)
+      expect(typeof outputs.totalOutputs).toBe('number')
+      expect(outputs.totalOutputs).toBeGreaterThanOrEqual(0)
+    }, 10000)
+
+    test('relinquishOutput - should relinquish an output from wallet tracking', async () => {
+      console.log('🗑️  Testing output relinquishment...')
+      // Use a dummy outpoint since we likely don't have real outputs to relinquish
+      const dummyOutpoint =
+        '0000000000000000000000000000000000000000000000000000000000000000:0'
+
+      try {
+        const result = await setup.wallet.relinquishOutput({
+          basket: 'default',
+          output: dummyOutpoint
+        })
+
+        console.log('✅ Output relinquished successfully')
+        expect(result).toBeDefined()
+        expect(result.relinquished).toBeDefined()
+      } catch (err: any) {
+        console.log('⚠️  Output relinquishment failed (expected with dummy outpoint)')
+        // Expected to fail with dummy outpoint
+        expect(err).toBeDefined()
+      }
+      console.log('✅ Output relinquishment test completed')
+    }, 10000)
+  })
+
+  // ============================================================================
+  // Certificates
+  // ============================================================================
+
+  describe('Certificates', () => {
+    test('acquireCertificate - should attempt to acquire a certificate', async () => {
+      console.log('📜 Testing certificate acquisition...')
+      try {
+        const result = await setup.wallet.acquireCertificate({
+          type: Buffer.from('test-certificate').toString('base64'),
+          certifier: setup.identityKey,
+          acquisitionProtocol: 'issuance',
+          certifierUrl: 'http://localhost:8000',
+          fields: {
+            name: 'Test User',
+            email: 'test@example.com'
+          },
+          privilegedReason: 'Demo acquisition'
+        })
+        console.log('📜 Certificate acquired successfully')
+        expect(result).toBeDefined()
+      } catch (err: any) {
+        console.log('⚠️  Certificate acquisition failed (expected in local test environment)')
+        // Expected to fail in test environment
+        expect(err).toBeDefined()
+      }
+      console.log('✅ Certificate acquisition test completed')
+    }, 10000)
+
+    test('listCertificates - should list wallet certificates', async () => {
+      const certs = await setup.wallet.listCertificates({
+        certifiers: [],
+        types: [],
+        limit: 10,
+        offset: 0
+      })
+
+      console.log(`📜 Listed ${certs.certificates.length} certificates from database`)
+      if (certs.certificates.length > 0) {
+        console.log(`   Certificate types: ${certs.certificates.map(c => c.type).join(', ')}`)
+      }
+
+      expect(certs).toBeDefined()
+      expect(certs.certificates).toBeDefined()
+      expect(Array.isArray(certs.certificates)).toBe(true)
+      expect(certs.certificates.length).toBeGreaterThanOrEqual(0)
+      if (certs.certificates.length > 0) {
+        const testCert = certs.certificates.find(
+          c => c.type === 'test-certificate'
+        )
+        if (testCert) {
+          expect(testCert.subject).toBeDefined()
+        }
+      }
+    }, 10000)
+
+    test('relinquishCertificate - should relinquish a certificate', async () => {
+      console.log('🗑️  Testing certificate relinquishment...')
+      // First check if we have any certificates to relinquish
+      const certs = await setup.wallet.listCertificates({
+        certifiers: [],
+        types: [],
+        limit: 10,
+        offset: 0
+      })
+
+      console.log(`📜 Found ${certs.certificates.length} certificates to potentially relinquish`)
+      if (certs.certificates.length === 0) {
+        console.log('⚠️  No certificates to relinquish, skipping test')
+        return
+      }
+
+      // Try to relinquish the first certificate
+      const cert = certs.certificates[0]
+      console.log(`🗑️  Attempting to relinquish certificate: ${cert.type}`)
+
+      try {