sovereignclaw 0.1.0 → 0.1.1

package/bin/sovereignclaw.js

@@ -109,8 +109,11 @@ Then run: sovereignclaw portfolio
 }
 
 function runScript(script, ...args) {
-  const scriptPath = join(__dirname, '..', 'scripts', script);
-  const child = spawn('npx', ['tsx', scriptPath, ...args, ...process.argv.slice(3)], {
+  // Use bundled JS from dist/ instead of TS
+  const jsScript = script.replace('.ts', '.js');
+  const scriptPath = join(__dirname, '..', 'dist', jsScript);
+  
+  const child = spawn('node', [scriptPath, ...args, ...process.argv.slice(3)], {
     stdio: 'inherit',
     env: {
       ...process.env,

package/dist/bridge.js

@@ -0,0 +1,336 @@
+// scripts/bridge.ts
+import { createWalletClient, createPublicClient, http, encodeFunctionData, parseUnits, formatUnits } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import { sepolia, baseSepolia, arbitrumSepolia, optimismSepolia } from "viem/chains";
+var TESTNET_CHAINS = {
+  "ethereum-sepolia": {
+    name: "Ethereum Sepolia",
+    domain: 0,
+    chainId: 11155111,
+    chain: sepolia,
+    usdc: "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238",
+    rpcUrl: "https://ethereum-sepolia-rpc.publicnode.com"
+  },
+  "base-sepolia": {
+    name: "Base Sepolia",
+    domain: 6,
+    chainId: 84532,
+    chain: baseSepolia,
+    usdc: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+    rpcUrl: "https://base-sepolia-rpc.publicnode.com"
+  },
+  "arbitrum-sepolia": {
+    name: "Arbitrum Sepolia",
+    domain: 3,
+    chainId: 421614,
+    chain: arbitrumSepolia,
+    usdc: "0x75faf114eafb1BDbe2F0316DF893fd58CE46AA4d"
+  },
+  "op-sepolia": {
+    name: "OP Sepolia",
+    domain: 2,
+    chainId: 11155420,
+    chain: optimismSepolia,
+    usdc: "0x5fd84259d66Cd46123540766Be93DFE6D43130D7"
+  }
+};
+var CCTP_CONTRACTS = {
+  testnet: {
+    tokenMessenger: "0x8FE6B999Dc680CcFDD5Bf7EB0974218be2542DAA",
+    messageTransmitter: "0xE737e5cEBEEBa77EFE34D4aa090756590b1CE275",
+    attestationApi: "https://iris-api-sandbox.circle.com"
+  },
+  mainnet: {
+    tokenMessenger: "0x28b5a0e9C621a5BadaA536219b3a228C8168cf5d",
+    messageTransmitter: "0x81D40F21F12A8F0E3252Bccb954D722d4c464B64",
+    attestationApi: "https://iris-api.circle.com"
+  }
+};
+var ERC20_ABI = [
+  {
+    type: "function",
+    name: "approve",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "spender", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }]
+  },
+  {
+    type: "function",
+    name: "balanceOf",
+    stateMutability: "view",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    type: "function",
+    name: "allowance",
+    stateMutability: "view",
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "spender", type: "address" }
+    ],
+    outputs: [{ name: "", type: "uint256" }]
+  }
+];
+var TOKEN_MESSENGER_ABI = [
+  {
+    type: "function",
+    name: "depositForBurn",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "amount", type: "uint256" },
+      { name: "destinationDomain", type: "uint32" },
+      { name: "mintRecipient", type: "bytes32" },
+      { name: "burnToken", type: "address" },
+      { name: "destinationCaller", type: "bytes32" },
+      { name: "maxFee", type: "uint256" },
+      { name: "minFinalityThreshold", type: "uint32" }
+    ],
+    outputs: []
+  }
+];
+var MESSAGE_TRANSMITTER_ABI = [
+  {
+    type: "function",
+    name: "receiveMessage",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "message", type: "bytes" },
+      { name: "attestation", type: "bytes" }
+    ],
+    outputs: [{ name: "success", type: "bool" }]
+  }
+];
+function addressToBytes32(address) {
+  return `0x000000000000000000000000${address.slice(2)}`;
+}
+var ZERO_BYTES32 = "0x0000000000000000000000000000000000000000000000000000000000000000";
+async function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var CCTPBridge = class {
+  privateKey;
+  isTestnet;
+  contracts;
+  constructor(privateKey, isTestnet = true) {
+    this.privateKey = privateKey;
+    this.isTestnet = isTestnet;
+    this.contracts = isTestnet ? CCTP_CONTRACTS.testnet : CCTP_CONTRACTS.mainnet;
+  }
+  getChainConfig(chainName) {
+    const normalized = chainName.toLowerCase().replace(/\s+/g, "-");
+    const config = TESTNET_CHAINS[normalized];
+    if (!config) {
+      throw new Error(`Unsupported chain: ${chainName}. Supported: ${Object.keys(TESTNET_CHAINS).join(", ")}`);
+    }
+    return config;
+  }
+  createClients(chainConfig) {
+    const account = privateKeyToAccount(this.privateKey);
+    const transport = chainConfig.rpcUrl ? http(chainConfig.rpcUrl) : http();
+    const walletClient = createWalletClient({
+      chain: chainConfig.chain,
+      transport,
+      account
+    });
+    const publicClient = createPublicClient({
+      chain: chainConfig.chain,
+      transport
+    });
+    return { walletClient, publicClient, account };
+  }
+  async getBalance(chainName) {
+    const chainConfig = this.getChainConfig(chainName);
+    const { publicClient, account } = this.createClients(chainConfig);
+    const balance = await publicClient.readContract({
+      address: chainConfig.usdc,
+      abi: ERC20_ABI,
+      functionName: "balanceOf",
+      args: [account.address]
+    });
+    return formatUnits(balance, 6);
+  }
+  async quote(sourceChain, destChain, amount) {
+    const source = this.getChainConfig(sourceChain);
+    const dest = this.getChainConfig(destChain);
+    const fee = "0.0005";
+    const received = (parseFloat(amount) - parseFloat(fee)).toFixed(4);
+    return {
+      sourceChain: source.name,
+      destChain: dest.name,
+      amount,
+      estimatedReceived: received,
+      fee,
+      estimatedTime: "1-2 minutes (Fast Transfer)"
+    };
+  }
+  async bridge(sourceChain, destChain, amount, recipient, onStatus) {
+    const log = onStatus || console.log;
+    const source = this.getChainConfig(sourceChain);
+    const dest = this.getChainConfig(destChain);
+    const amountWei = parseUnits(amount, 6);
+    const { walletClient: sourceWallet, publicClient: sourcePublic, account } = this.createClients(source);
+    const { walletClient: destWallet } = this.createClients(dest);
+    const recipientAddress = recipient || account.address;
+    const recipientBytes32 = addressToBytes32(recipientAddress);
+    log("\u{1F4CA} Checking USDC balance...");
+    const balance = await sourcePublic.readContract({
+      address: source.usdc,
+      abi: ERC20_ABI,
+      functionName: "balanceOf",
+      args: [account.address]
+    });
+    if (balance < amountWei) {
+      throw new Error(`Insufficient USDC. Have: ${formatUnits(balance, 6)}, Need: ${amount}`);
+    }
+    log("\u2705 Step 1/4: Approving USDC...");
+    const allowance = await sourcePublic.readContract({
+      address: source.usdc,
+      abi: ERC20_ABI,
+      functionName: "allowance",
+      args: [account.address, this.contracts.tokenMessenger]
+    });
+    if (allowance < amountWei) {
+      const approveTx = await sourceWallet.sendTransaction({
+        to: source.usdc,
+        data: encodeFunctionData({
+          abi: ERC20_ABI,
+          functionName: "approve",
+          args: [this.contracts.tokenMessenger, amountWei * 10n]
+          // Approve extra for future txs
+        })
+      });
+      log(`   Approval TX: ${approveTx}`);
+      await sourcePublic.waitForTransactionReceipt({ hash: approveTx });
+    } else {
+      log("   Already approved.");
+    }
+    log("\u{1F525} Step 2/4: Burning USDC on source chain...");
+    const maxFee = 100000n;
+    const minFinalityThreshold = 1e3;
+    const burnTx = await sourceWallet.sendTransaction({
+      to: this.contracts.tokenMessenger,
+      data: encodeFunctionData({
+        abi: TOKEN_MESSENGER_ABI,
+        functionName: "depositForBurn",
+        args: [
+          amountWei,
+          dest.domain,
+          recipientBytes32,
+          source.usdc,
+          ZERO_BYTES32,
+          maxFee,
+          minFinalityThreshold
+        ]
+      })
+    });
+    log(`   Burn TX: ${burnTx}`);
+    await sourcePublic.waitForTransactionReceipt({ hash: burnTx });
+    log("\u23F3 Step 3/4: Waiting for attestation...");
+    const attestation = await this.waitForAttestation(source.domain, burnTx, log);
+    log("   \u2705 Attestation received!");
+    log("\u{1FA99} Step 4/4: Minting USDC on destination chain...");
+    const mintTx = await destWallet.sendTransaction({
+      to: this.contracts.messageTransmitter,
+      data: encodeFunctionData({
+        abi: MESSAGE_TRANSMITTER_ABI,
+        functionName: "receiveMessage",
+        args: [attestation.message, attestation.attestation]
+      })
+    });
+    log(`   Mint TX: ${mintTx}`);
+    const destPublic = createPublicClient({
+      chain: dest.chain,
+      transport: http()
+    });
+    await destPublic.waitForTransactionReceipt({ hash: mintTx });
+    log("\u2705 Bridge complete!");
+    return {
+      burnTxHash: burnTx,
+      mintTxHash: mintTx,
+      amountReceived: formatUnits(amountWei - maxFee, 6)
+    };
+  }
+  async waitForAttestation(sourceDomain, txHash, log) {
+    const url = `${this.contracts.attestationApi}/v2/messages/${sourceDomain}?transactionHash=${txHash}`;
+    let attempts = 0;
+    const maxAttempts = 60;
+    while (attempts < maxAttempts) {
+      try {
+        const response = await fetch(url);
+        if (response.ok) {
+          const data = await response.json();
+          if (data.messages?.[0]?.status === "complete") {
+            return {
+              message: data.messages[0].message,
+              attestation: data.messages[0].attestation
+            };
+          }
+        }
+        attempts++;
+        if (attempts % 6 === 0) {
+          log(`   Still waiting... (${attempts * 5}s)`);
+        }
+        await sleep(5e3);
+      } catch (error) {
+        attempts++;
+        await sleep(5e3);
+      }
+    }
+    throw new Error(`Attestation timeout after ${maxAttempts * 5}s. TX: ${txHash}`);
+  }
+};
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.length < 4) {
+    console.log(`
+Usage: npx tsx bridge.ts <action> <source> <dest> <amount> [recipient]
+
+Actions:
+  quote   - Get a quote without executing
+  bridge  - Execute the bridge
+
+Examples:
+  npx tsx bridge.ts quote ethereum-sepolia base-sepolia 10
+  npx tsx bridge.ts bridge ethereum-sepolia base-sepolia 10
+
+Environment:
+  PRIVATE_KEY - Your wallet private key
+`);
+    process.exit(1);
+  }
+  const [action, source, dest, amount, recipient] = args;
+  const privateKey = process.env.PRIVATE_KEY;
+  if (action === "bridge" && !privateKey) {
+    console.error("Error: PRIVATE_KEY environment variable required for bridging");
+    process.exit(1);
+  }
+  const bridge = new CCTPBridge(privateKey || "0x0", true);
+  if (action === "quote") {
+    const quote = await bridge.quote(source, dest, amount);
+    console.log(`
+\u{1F504} CCTP Bridge Quote: ${quote.amount} USDC
+\u{1F4E4} From: ${quote.sourceChain}
+\u{1F4E5} To: ${quote.destChain}
+
+\u{1F4B0} You receive: ~${quote.estimatedReceived} USDC
+\u26FD Fee: ~${quote.fee} USDC
+\u23F1\uFE0F Est. time: ${quote.estimatedTime}
+`);
+  } else if (action === "bridge") {
+    const result = await bridge.bridge(source, dest, amount, recipient);
+    console.log(`
+\u2705 Bridge Complete!
+\u{1F525} Burn TX: ${result.burnTxHash}
+\u{1FA99} Mint TX: ${result.mintTxHash}
+\u{1F4B0} Received: ${result.amountReceived} USDC
+`);
+  }
+}
+main().catch(console.error);
+export {
+  CCTPBridge
+};