@veridex/sdk 1.0.0-beta.1

package/dist/chains/aptos/index.js

@@ -0,0 +1,563 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/chains/aptos/index.ts
+var aptos_exports = {};
+__export(aptos_exports, {
+  AptosClient: () => AptosClient
+});
+module.exports = __toCommonJS(aptos_exports);
+
+// src/chains/aptos/AptosClient.ts
+var import_aptos = require("aptos");
+var import_js_sha3 = require("js-sha3");
+
+// src/payload.ts
+var import_ethers = require("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 = import_ethers.ethers.zeroPadValue(import_ethers.ethers.toBeHex(amount), 32);
+  return import_ethers.ethers.concat([
+    import_ethers.ethers.toBeHex(ACTION_TRANSFER, 1),
+    tokenPadded,
+    recipientPadded,
+    amountBytes
+  ]);
+}
+function encodeBridgeAction(token, amount, targetChain, recipient) {
+  const tokenPadded = padTo32Bytes(token);
+  const amountBytes = import_ethers.ethers.zeroPadValue(import_ethers.ethers.toBeHex(amount), 32);
+  const targetChainBytes = import_ethers.ethers.toBeHex(targetChain, 2);
+  const recipientPadded = padTo32Bytes(recipient);
+  return import_ethers.ethers.concat([
+    import_ethers.ethers.toBeHex(ACTION_BRIDGE, 1),
+    tokenPadded,
+    amountBytes,
+    targetChainBytes,
+    recipientPadded
+  ]);
+}
+function encodeExecuteAction(target, value, data) {
+  const targetPadded = padTo32Bytes(target);
+  const valueBytes = import_ethers.ethers.zeroPadValue(import_ethers.ethers.toBeHex(value), 32);
+  const dataBytes = import_ethers.ethers.getBytes(data);
+  const dataLengthBytes = import_ethers.ethers.toBeHex(dataBytes.length, 2);
+  return import_ethers.ethers.concat([
+    import_ethers.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
+var AptosClient = class {
+  config;
+  client;
+  moduleAddress;
+  constructor(config) {
+    this.config = {
+      name: `Aptos ${config.network || "mainnet"}`,
+      chainId: config.wormholeChainId,
+      wormholeChainId: config.wormholeChainId,
+      rpcUrl: config.rpcUrl,
+      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
+      }
+    };
+    this.client = new import_aptos.AptosClient(config.rpcUrl);
+    this.moduleAddress = config.moduleAddress;
+  }
+  getConfig() {
+    return this.config;
+  }
+  async getNonce(userKeyHash) {
+    try {
+      const vaultAddress = this.computeVaultAddressFromHash(userKeyHash);
+      const resource = await this.client.getAccountResource(
+        vaultAddress,
+        `${this.moduleAddress}::vault::Vault`
+      );
+      if (resource && resource.data) {
+        const data = resource.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
+    };
+  }
+  async getVaultAddress(userKeyHash) {
+    try {
+      const vaultAddress = this.computeVaultAddressFromHash(userKeyHash);
+      const account = await this.client.getAccount(vaultAddress);
+      if (account) {
+        return vaultAddress;
+      }
+      return null;
+    } catch (error) {
+      if (error?.status === 404) {
+        return null;
+      }
+      console.error("Error getting vault address:", error);
+      return null;
+    }
+  }
+  /**
+   * Compute vault address using resource account derivation
+   * On Aptos, vaults are derived from the module address + user key hash
+   */
+  computeVaultAddress(userKeyHash) {
+    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 = (0, import_js_sha3.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(
+        address,
+        "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(
+        ownerAddress,
+        `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 = (0, import_js_sha3.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 = (0, import_js_sha3.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(txHash);
+  }
+  /**
+   * Wait for transaction confirmation
+   */
+  async waitForTransaction(txHash, timeoutSecs = 30) {
+    return await this.client.waitForTransactionWithResult(txHash, {
+      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(
+        vaultAddress,
+        `${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(
+        this.moduleAddress,
+        `${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(
+        this.moduleAddress,
+        `${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;
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AptosClient
+});
+//# sourceMappingURL=index.js.map