@veridex/sdk 1.0.0-beta.21 → 1.0.0-beta.23

package/dist/chains/aptos/index.mjs

@@ -1,577 +1,8 @@
-// src/chains/aptos/AptosClient.ts
-import { Aptos, AptosConfig, Network } from "@aptos-labs/ts-sdk";
-import { sha3_256 } from "js-sha3";
-
-// src/payload.ts
-import { ethers } from "ethers";
-
-// src/constants.ts
-var ACTION_TRANSFER = 1;
-var ACTION_EXECUTE = 2;
-var ACTION_BRIDGE = 4;
-
-// src/payload.ts
-function encodeTransferAction(token, recipient, amount) {
-  const tokenPadded = padTo32Bytes(token);
-  const recipientPadded = padTo32Bytes(recipient);
-  const amountBytes = ethers.zeroPadValue(ethers.toBeHex(amount), 32);
-  return ethers.concat([
-    ethers.toBeHex(ACTION_TRANSFER, 1),
-    tokenPadded,
-    recipientPadded,
-    amountBytes
-  ]);
-}
-function encodeBridgeAction(token, amount, targetChain, recipient) {
-  const tokenPadded = padTo32Bytes(token);
-  const amountBytes = ethers.zeroPadValue(ethers.toBeHex(amount), 32);
-  const targetChainBytes = ethers.toBeHex(targetChain, 2);
-  const recipientPadded = padTo32Bytes(recipient);
-  return ethers.concat([
-    ethers.toBeHex(ACTION_BRIDGE, 1),
-    tokenPadded,
-    amountBytes,
-    targetChainBytes,
-    recipientPadded
-  ]);
-}
-function encodeExecuteAction(target, value, data) {
-  const targetPadded = padTo32Bytes(target);
-  const valueBytes = ethers.zeroPadValue(ethers.toBeHex(value), 32);
-  const dataBytes = ethers.getBytes(data);
-  const dataLengthBytes = ethers.toBeHex(dataBytes.length, 2);
-  return ethers.concat([
-    ethers.toBeHex(ACTION_EXECUTE, 1),
-    targetPadded,
-    valueBytes,
-    dataLengthBytes,
-    data
-  ]);
-}
-function padTo32Bytes(address) {
-  if (address.toLowerCase() === "native") {
-    return "0x" + "0".repeat(64);
-  }
-  if (address.startsWith("0x")) {
-    const hex2 = address.replace("0x", "");
-    if (!/^[0-9a-fA-F]*$/.test(hex2)) {
-      throw new Error(`Invalid address: ${address}. Expected hex string or 'native'.`);
-    }
-    return "0x" + hex2.padStart(64, "0");
-  }
-  const base58Chars = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
-  for (const char of address) {
-    if (!base58Chars.includes(char)) {
-      throw new Error(`Invalid address: ${address}. Contains invalid base58 character '${char}'.`);
-    }
-  }
-  let value = BigInt(0);
-  for (const char of address) {
-    value = value * 58n + BigInt(base58Chars.indexOf(char));
-  }
-  let hex = value.toString(16);
-  if (hex.length > 64) {
-    throw new Error(`Invalid address: ${address}. Decoded value too large for 32 bytes.`);
-  }
-  return "0x" + hex.padStart(64, "0");
-}
-
-// src/chains/aptos/AptosClient.ts
-function getAptosNetworkEnum(network) {
-  if (network === "mainnet") return Network.MAINNET;
-  if (network === "devnet") return Network.DEVNET;
-  return Network.TESTNET;
-}
-var AptosClient = class {
-  config;
-  client;
-  moduleAddress;
-  constructor(config) {
-    const network = getAptosNetworkEnum(config.network);
-    this.config = {
-      name: `Aptos ${config.network || "mainnet"}`,
-      chainId: config.wormholeChainId,
-      wormholeChainId: config.wormholeChainId,
-      rpcUrl: config.rpcUrl,
-      // Keep for reference, but not used for SDK
-      explorerUrl: config.network === "testnet" ? "https://explorer.aptoslabs.com?network=testnet" : "https://explorer.aptoslabs.com",
-      isEvm: false,
-      contracts: {
-        hub: void 0,
-        // Aptos is a spoke only
-        wormholeCoreBridge: config.wormholeCoreBridge,
-        tokenBridge: config.tokenBridge
-      }
-    };
-    const aptosConfig = new AptosConfig({ network });
-    this.client = new Aptos(aptosConfig);
-    this.moduleAddress = config.moduleAddress;
-  }
-  getConfig() {
-    return this.config;
-  }
-  async getNonce(userKeyHash) {
-    try {
-      const vaultAddress = this.computeVaultAddressFromHash(userKeyHash);
-      const resources = await this.client.getAccountResources({
-        accountAddress: vaultAddress
-      });
-      const vaultResource = resources.find(
-        (r) => r.type === `${this.moduleAddress}::vault::Vault`
-      );
-      if (!vaultResource) {
-        return 0n;
-      }
-      if (vaultResource && vaultResource.data) {
-        const data = vaultResource.data;
-        return BigInt(data.nonce || 0);
-      }
-      return 0n;
-    } catch (error) {
-      console.error("Error getting nonce:", error);
-      return 0n;
-    }
-  }
-  async getMessageFee() {
-    try {
-      return 0n;
-    } catch (error) {
-      console.error("Error getting message fee:", error);
-      return 0n;
-    }
-  }
-  async buildTransferPayload(params) {
-    return encodeTransferAction(
-      params.token,
-      params.recipient,
-      params.amount
-    );
-  }
-  async buildExecutePayload(params) {
-    return encodeExecuteAction(
-      params.target,
-      params.value,
-      params.data
-    );
-  }
-  async buildBridgePayload(params) {
-    return encodeBridgeAction(
-      params.token,
-      params.amount,
-      params.destinationChain,
-      params.recipient
-    );
-  }
-  async dispatch(signature, publicKeyX, publicKeyY, targetChain, actionPayload, nonce, signer) {
-    void signature;
-    void publicKeyX;
-    void publicKeyY;
-    void targetChain;
-    void actionPayload;
-    void nonce;
-    void signer;
-    throw new Error(
-      "Direct dispatch not supported on Aptos spoke chains. Actions must be dispatched from the Hub (EVM) chain. This client is for receiving cross-chain messages only."
-    );
-  }
-  /**
-   * Dispatch an action via relayer (gasless)
-   * Note: On Aptos, this still goes through the Hub chain
-   * Aptos is a spoke-only chain in Veridex architecture
-   */
-  async dispatchGasless(signature, publicKeyX, publicKeyY, targetChain, actionPayload, nonce, relayerUrl) {
-    const keyHash = this.computeKeyHash(publicKeyX, publicKeyY);
-    const message = this.buildMessage(keyHash, targetChain, actionPayload, nonce);
-    const request = {
-      messageHash: message,
-      r: "0x" + signature.r.toString(16).padStart(64, "0"),
-      s: "0x" + signature.s.toString(16).padStart(64, "0"),
-      publicKeyX: "0x" + publicKeyX.toString(16).padStart(64, "0"),
-      publicKeyY: "0x" + publicKeyY.toString(16).padStart(64, "0"),
-      targetChain,
-      actionPayload,
-      nonce: Number(nonce)
-    };
-    const response = await fetch(`${relayerUrl}/api/v1/submit`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify(request)
-    });
-    if (!response.ok) {
-      const error = await response.json().catch(() => ({ error: response.statusText }));
-      throw new Error(`Relayer submission failed: ${error.error || response.statusText}`);
-    }
-    const result = await response.json();
-    if (!result.success) {
-      throw new Error(`Relayer submission failed: ${result.error}`);
-    }
-    return {
-      transactionHash: result.txHash,
-      sequence: BigInt(result.sequence || "0"),
-      userKeyHash: keyHash,
-      targetChain
-    };
-  }
-  /**
-   * Get vault address from on-chain VaultRegistry.
-   * Queries the get_vault_address view function which looks up the vault in the registry.
-   */
-  async getVaultAddress(userKeyHash) {
-    try {
-      const rawHex = userKeyHash.startsWith("0x") ? userKeyHash.slice(2).toLowerCase() : userKeyHash.toLowerCase();
-      const keyHashHex = `0x${rawHex.padStart(64, "0")}`;
-      const existsResponse = await this.client.view({
-        payload: {
-          function: `${this.moduleAddress}::spoke::vault_exists`,
-          typeArguments: [],
-          functionArguments: [keyHashHex]
-        }
-      });
-      if (!existsResponse || existsResponse.length === 0 || existsResponse[0] !== true) {
-        return null;
-      }
-      const response = await this.client.view({
-        payload: {
-          function: `${this.moduleAddress}::spoke::get_vault_address`,
-          typeArguments: [],
-          functionArguments: [keyHashHex]
-        }
-      });
-      if (response && response.length > 0) {
-        const vaultAddress = response[0];
-        return vaultAddress;
-      }
-      return null;
-    } catch (error) {
-      if (error?.message?.includes("E_VAULT_NOT_FOUND") || error?.message?.includes("error code 6") || error?.status === 404) {
-        return null;
-      }
-      console.error("Error getting vault address from registry:", error);
-      return null;
-    }
-  }
-  /**
-   * @deprecated Use getVaultAddress() instead - this method uses incorrect address derivation.
-   * On Aptos, vaults are created as named objects by the relayer, not resource accounts.
-   * The vault address depends on which relayer created it, so must be queried on-chain.
-   */
-  computeVaultAddress(userKeyHash) {
-    console.warn(
-      "computeVaultAddress() is deprecated for Aptos. Use getVaultAddress() to query the on-chain VaultRegistry instead."
-    );
-    return this.computeVaultAddressFromHash(userKeyHash);
-  }
-  computeVaultAddressFromHash(userKeyHash) {
-    const sourceAddress = this.hexToBytes(this.moduleAddress.replace("0x", ""));
-    const seed = this.hexToBytes(userKeyHash.replace("0x", ""));
-    const scheme = new Uint8Array([254]);
-    const combined = new Uint8Array([...sourceAddress, ...seed, ...scheme]);
-    const hash = sha3_256(combined);
-    return "0x" + hash;
-  }
-  /**
-   * Convert hex string to Uint8Array (browser-compatible)
-   */
-  hexToBytes(hex) {
-    const bytes = new Uint8Array(hex.length / 2);
-    for (let i = 0; i < hex.length; i += 2) {
-      bytes[i / 2] = parseInt(hex.substr(i, 2), 16);
-    }
-    return bytes;
-  }
-  async vaultExists(userKeyHash) {
-    const address = await this.getVaultAddress(userKeyHash);
-    return address !== null;
-  }
-  async createVault(userKeyHash, signer) {
-    void userKeyHash;
-    void signer;
-    throw new Error(
-      "Vault creation on Aptos must be done via cross-chain message from Hub. Use the Hub chain client to dispatch a vault creation action targeting Aptos."
-    );
-  }
-  async createVaultSponsored(userKeyHash, sponsorPrivateKey, rpcUrl) {
-    void userKeyHash;
-    void sponsorPrivateKey;
-    void rpcUrl;
-    throw new Error(
-      "Vault creation on Aptos must be done via cross-chain message from Hub. Use relayer gasless submission to create vault."
-    );
-  }
-  /**
-   * Create a vault via the relayer (sponsored/gasless)
-   * This is the recommended way to create Aptos vaults
-   * 
-   * The relayer will dispatch a vault creation action from Hub to Aptos spoke
-   */
-  async createVaultViaRelayer(userKeyHash, relayerUrl) {
-    const response = await fetch(`${relayerUrl}/api/v1/aptos/vault`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
-        userKeyHash,
-        chainId: this.config.wormholeChainId
-      })
-    });
-    const result = await response.json();
-    if (!response.ok || !result.success) {
-      throw new Error(result.error || "Failed to create vault via relayer");
-    }
-    return {
-      address: result.vaultAddress,
-      transactionHash: result.transactionHash || "",
-      blockNumber: 0,
-      gasUsed: 0n,
-      alreadyExisted: result.alreadyExists || false,
-      sponsoredBy: "relayer"
-    };
-  }
-  /**
-   * Get vault info via relayer (includes existence check)
-   */
-  async getVaultViaRelayer(userKeyHash, relayerUrl) {
-    const response = await fetch(
-      `${relayerUrl}/api/v1/aptos/vault/${userKeyHash}?chainId=${this.config.wormholeChainId}`
-    );
-    if (!response.ok) {
-      throw new Error("Failed to get vault info from relayer");
-    }
-    const result = await response.json();
-    return {
-      vaultAddress: result.vaultAddress,
-      exists: result.exists
-    };
-  }
-  async estimateVaultCreationGas(userKeyHash) {
-    void userKeyHash;
-    return 100000n;
-  }
-  getFactoryAddress() {
-    return void 0;
-  }
-  getImplementationAddress() {
-    return void 0;
-  }
-  // ========================================================================
-  // Balance Methods
-  // ========================================================================
-  /**
-   * Get native APT balance
-   */
-  async getNativeBalance(address) {
-    try {
-      const resource = await this.client.getAccountResource({
-        accountAddress: address,
-        resourceType: "0x1::coin::CoinStore<0x1::aptos_coin::AptosCoin>"
-      });
-      if (resource && resource.data) {
-        const data = resource.data;
-        return BigInt(data.coin?.value || 0);
-      }
-      return 0n;
-    } catch (error) {
-      console.error("Error getting native balance:", error);
-      return 0n;
-    }
-  }
-  /**
-   * Get fungible asset (FA) or coin balance
-   */
-  async getTokenBalance(tokenAddress, ownerAddress) {
-    try {
-      const coinType = tokenAddress.includes("::") ? tokenAddress : `${tokenAddress}::coin::Coin`;
-      const resource = await this.client.getAccountResource({
-        accountAddress: ownerAddress,
-        resourceType: `0x1::coin::CoinStore<${coinType}>`
-      });
-      if (resource && resource.data) {
-        const data = resource.data;
-        return BigInt(data.coin?.value || 0);
-      }
-      return 0n;
-    } catch (error) {
-      try {
-        console.warn("FA balance query not fully implemented yet");
-        return 0n;
-      } catch (faError) {
-        console.error("Error getting token balance:", error);
-        return 0n;
-      }
-    }
-  }
-  // ========================================================================
-  // Utility Methods
-  // ========================================================================
-  /**
-   * Compute key hash from public key coordinates
-   * Matches EVM keccak256(abi.encode(publicKeyX, publicKeyY))
-   */
-  computeKeyHash(publicKeyX, publicKeyY) {
-    const xHex = publicKeyX.toString(16).padStart(64, "0");
-    const yHex = publicKeyY.toString(16).padStart(64, "0");
-    const xBytes = this.hexToBytes(xHex);
-    const yBytes = this.hexToBytes(yHex);
-    const combined = new Uint8Array([...xBytes, ...yBytes]);
-    const hash = sha3_256(combined);
-    return "0x" + hash;
-  }
-  /**
-   * Build message for signing (matches Hub chain format)
-   */
-  buildMessage(keyHash, targetChain, actionPayload, nonce) {
-    const keyHashBytes = this.hexToBytes(keyHash.replace("0x", ""));
-    const targetChainBytes = new Uint8Array(2);
-    targetChainBytes[0] = targetChain >> 8 & 255;
-    targetChainBytes[1] = targetChain & 255;
-    const payloadBytes = this.hexToBytes(actionPayload.replace("0x", ""));
-    const nonceHex = nonce.toString(16).padStart(64, "0");
-    const nonceBytes = this.hexToBytes(nonceHex);
-    const combined = new Uint8Array([
-      ...keyHashBytes,
-      ...targetChainBytes,
-      ...payloadBytes,
-      ...nonceBytes
-    ]);
-    const hash = sha3_256(combined);
-    return "0x" + hash;
-  }
-  /**
-   * Get Aptos client instance for advanced usage
-   */
-  getClient() {
-    return this.client;
-  }
-  /**
-   * Get module address
-   */
-  getModuleAddress() {
-    return this.moduleAddress;
-  }
-  /**
-   * Get current ledger version
-   */
-  async getLedgerVersion() {
-    const ledgerInfo = await this.client.getLedgerInfo();
-    return BigInt(ledgerInfo.ledger_version);
-  }
-  /**
-   * Get transaction by hash
-   */
-  async getTransaction(txHash) {
-    return await this.client.getTransactionByHash({ transactionHash: txHash });
-  }
-  /**
-   * Wait for transaction confirmation
-   */
-  async waitForTransaction(txHash, timeoutSecs = 30) {
-    return await this.client.waitForTransaction({
-      transactionHash: txHash,
-      options: {
-        timeoutSecs,
-        checkSuccess: true
-      }
-    });
-  }
-  // ============================================================================
-  // Social Recovery Methods (Issue #23)
-  // ============================================================================
-  // 
-  // Note: Social recovery is managed on the Hub chain (EVM).
-  // Aptos spokes receive and execute recovery VAAs broadcast from the Hub.
-  // The relayer service handles submitting recovery transactions to Aptos.
-  //
-  // SDK users should use EVMClient methods for guardian management and
-  // recovery initiation on the Hub chain.
-  // ============================================================================
-  /**
-   * Get vault resource for an owner
-   * 
-   * @param ownerKeyHash - Owner's passkey hash (32 bytes as hex)
-   * @returns Vault resource data or null if not found
-   */
-  async getVaultResource(ownerKeyHash) {
-    try {
-      const vaultAddress = this.computeVaultAddressFromHash(ownerKeyHash);
-      const resource = await this.client.getAccountResource({
-        accountAddress: vaultAddress,
-        resourceType: `${this.moduleAddress}::vault::Vault`
-      });
-      if (!resource || !resource.data) {
-        return null;
-      }
-      const data = resource.data;
-      return {
-        ownerKeyHash: data.owner_key_hash || ownerKeyHash,
-        authorizedSigners: data.authorized_signers || [],
-        nonce: BigInt(data.nonce || 0)
-      };
-    } catch (error) {
-      console.error("Error getting vault resource:", error);
-      return null;
-    }
-  }
-  /**
-   * Get authorized signers for a vault
-   * 
-   * @param ownerKeyHash - Owner's passkey hash (32 bytes as hex)
-   * @returns Array of authorized signer key hashes
-   */
-  async getAuthorizedSigners(ownerKeyHash) {
-    const vaultResource = await this.getVaultResource(ownerKeyHash);
-    return vaultResource?.authorizedSigners || [];
-  }
-  /**
-   * Check if a VAA has been processed (for replay protection)
-   * 
-   * @param vaaHash - VAA hash as hex string
-   * @returns Whether the VAA has been processed
-   */
-  async isVaaProcessed(vaaHash) {
-    try {
-      const resource = await this.client.getAccountResource({
-        accountAddress: this.moduleAddress,
-        resourceType: `${this.moduleAddress}::spoke::ProcessedVAAs`
-      });
-      if (!resource || !resource.data) {
-        return false;
-      }
-      const data = resource.data;
-      const processedVaas = data.processed || [];
-      const normalizedHash = vaaHash.toLowerCase().replace("0x", "");
-      return processedVaas.some(
-        (hash) => hash.toLowerCase().replace("0x", "") === normalizedHash
-      );
-    } catch (error) {
-      console.error("Error checking VAA status:", error);
-      return false;
-    }
-  }
-  /**
-   * Check if protocol is paused
-   * 
-   * @returns Whether the protocol is paused
-   */
-  async isProtocolPaused() {
-    try {
-      const resource = await this.client.getAccountResource({
-        accountAddress: this.moduleAddress,
-        resourceType: `${this.moduleAddress}::spoke::Config`
-      });
-      if (!resource || !resource.data) {
-        return false;
-      }
-      const data = resource.data;
-      return data.paused === true;
-    } catch (error) {
-      console.error("Error checking pause status:", error);
-      return false;
-    }
-  }
-};
+import {
+  AptosClient
+} from "../../chunk-FQ2WU7PX.mjs";
+import "../../chunk-BKTCPT7P.mjs";
+import "../../chunk-K73Y36KS.mjs";
 export {
   AptosClient
 };