@vleap/warps-adapter-fastset 0.1.0-alpha.19 → 0.1.0-alpha.20

package/dist/index.mjs

@@ -6,106 +6,243 @@ var WarpFastsetConstants = {
 // src/main.ts
 import { WarpChainName } from "@vleap/warps";
 
-// src/sdk/FastsetClient.ts
-import { getPublicKey } from "@noble/ed25519";
-
-// src/sdk/TransactionSigner.ts
-import { sign } from "@noble/ed25519";
+// src/WarpFastsetDataLoader.ts
+import * as bech323 from "bech32";
 
-// src/sdk/types.ts
+// src/sdk/FastsetClient.ts
 import { bcs } from "@mysten/bcs";
-BigInt.prototype.toJSON = function() {
-  return Number(this);
-};
-var Bytes32 = bcs.fixedArray(32, bcs.u8());
-var PublicKey = Bytes32;
-var Address = bcs.enum("Address", {
-  External: PublicKey,
-  FastSet: PublicKey
-});
-var Amount = bcs.u256().transform({
-  input: (val) => hexToDecimal(val.toString()),
-  output: (value) => value
-});
-var UserData = bcs.option(Bytes32);
-var Nonce = bcs.u64();
-var Transfer = bcs.struct("Transfer", {
-  recipient: Address,
-  amount: Amount,
-  user_data: UserData
-});
-var ClaimType = bcs.enum("ClaimType", {
-  Transfer
-});
-var BcsTransaction = bcs.struct("Transaction", {
-  sender: PublicKey,
-  nonce: Nonce,
+import * as bech32 from "bech32";
+var bcsTransaction = bcs.struct("Transaction", {
+  sender: bcs.fixedArray(32, bcs.u8()),
+  recipient: bcs.enum("Address", {
+    External: bcs.fixedArray(32, bcs.u8()),
+    FastSet: bcs.fixedArray(32, bcs.u8())
+  }),
+  nonce: bcs.u64(),
   timestamp_nanos: bcs.u128(),
-  claim: ClaimType
+  claim: bcs.enum("ClaimType", {
+    Transfer: bcs.struct("Transfer", {
+      recipient: bcs.enum("Address", {
+        External: bcs.fixedArray(32, bcs.u8()),
+        FastSet: bcs.fixedArray(32, bcs.u8())
+      }),
+      amount: bcs.string(),
+      user_data: bcs.option(bcs.fixedArray(32, bcs.u8()))
+    }),
+    TokenTransfer: bcs.struct("TokenTransfer", {
+      token_id: bcs.fixedArray(32, bcs.u8()),
+      amount: bcs.string(),
+      user_data: bcs.option(bcs.fixedArray(32, bcs.u8()))
+    }),
+    TokenCreation: bcs.struct("TokenCreation", {
+      token_name: bcs.string(),
+      decimals: bcs.u8(),
+      initial_amount: bcs.string(),
+      mints: bcs.vector(bcs.fixedArray(32, bcs.u8())),
+      user_data: bcs.option(bcs.fixedArray(32, bcs.u8()))
+    }),
+    TokenManagement: bcs.struct("TokenManagement", {
+      token_id: bcs.fixedArray(32, bcs.u8()),
+      update_id: bcs.u64(),
+      new_admin: bcs.option(bcs.fixedArray(32, bcs.u8())),
+      mints: bcs.vector(
+        bcs.tuple([
+          bcs.enum("AddressChange", {
+            Add: bcs.fixedArray(32, bcs.u8()),
+            Remove: bcs.fixedArray(32, bcs.u8())
+          }),
+          bcs.fixedArray(32, bcs.u8())
+        ])
+      ),
+      user_data: bcs.option(bcs.fixedArray(32, bcs.u8()))
+    }),
+    Mint: bcs.struct("Mint", {
+      token_id: bcs.fixedArray(32, bcs.u8()),
+      amount: bcs.string()
+    }),
+    ExternalClaim: bcs.struct("ExternalClaim", {
+      claim: bcs.struct("ExternalClaimBody", {
+        verifier_committee: bcs.vector(bcs.fixedArray(32, bcs.u8())),
+        verifier_quorum: bcs.u64(),
+        claim_data: bcs.vector(bcs.u8())
+      }),
+      signatures: bcs.vector(bcs.tuple([bcs.fixedArray(32, bcs.u8()), bcs.fixedArray(64, bcs.u8())]))
+    })
+  })
 });
-function hexToDecimal(hex) {
-  return BigInt(`0x${hex}`).toString();
-}
-
-// src/sdk/TransactionSigner.ts
-var TransactionSigner = class {
-  static async signTransaction(transaction, privateKey) {
-    const msg = BcsTransaction.serialize(transaction);
-    const msgBytes = msg.toBytes();
-    const prefix = new TextEncoder().encode("Transaction::");
-    const dataToSign = new Uint8Array(prefix.length + msgBytes.length);
-    dataToSign.set(prefix, 0);
-    dataToSign.set(msgBytes, prefix.length);
-    return sign(dataToSign, privateKey);
+var FastsetClient = class {
+  constructor(config, chain) {
+    if (config && "proxyUrl" in config) {
+      this.apiUrl = config.proxyUrl;
+    } else if (config && chain) {
+      this.apiUrl = chain.defaultApiUrl;
+    } else {
+      this.apiUrl = "https://rpc.fastset.xyz";
+    }
   }
-};
-
-// src/sdk/Wallet.ts
-import * as bech32 from "bech32";
-
-// src/sdk/Claim.ts
-var Claim = class {
-  static fromTransaction(transaction) {
-    const claimType = Object.keys(transaction.claim)[0];
-    const claimData = transaction.claim[claimType];
-    switch (claimType) {
-      case "Transfer":
-        return TransferClaim.fromData(claimData);
-      default:
-        throw new Error(`Unknown claim type: ${claimType}`);
+  async makeRequest(method, params = {}) {
+    const response = await fetch(this.apiUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        method,
+        params,
+        id: Date.now()
+      })
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`);
+    }
+    const jsonResponse = await response.json();
+    if (jsonResponse.error) {
+      throw new Error(`JSON-RPC error ${jsonResponse.error.code}: ${jsonResponse.error.message}`);
+    }
+    return jsonResponse.result;
+  }
+  async getAccountInfo(address, token_balance_filter, certificate_by_nonce) {
+    return this.makeRequest("set_getAccountInfo", {
+      address,
+      token_balance_filter,
+      certificate_by_nonce
+    });
+  }
+  async getTokenInfo(token_ids) {
+    return this.makeRequest("set_getTokenInfo", {
+      token_ids
+    });
+  }
+  async getTransfers(page) {
+    return this.makeRequest("set_getTransfers", { page });
+  }
+  async getClaims(confirmed, page) {
+    return this.makeRequest("set_getClaims", { confirmed, page });
+  }
+  async getClaimsByAddress(address, page) {
+    return this.makeRequest("set_getClaimsByAddress", {
+      address,
+      page
+    });
+  }
+  async getNextNonce(address) {
+    if (typeof address === "string") {
+      const addressBytes = this.addressToBytes(address);
+      const accountInfo2 = await this.getAccountInfo(addressBytes);
+      return accountInfo2.next_nonce;
+    }
+    const accountInfo = await this.getAccountInfo(address);
+    return accountInfo.next_nonce;
+  }
+  async submitTransaction(transaction, signature) {
+    const signatureArray = Array.isArray(signature) ? signature : Array.from(signature);
+    return this.makeRequest("set_submitTransaction", {
+      transaction,
+      signature: signatureArray
+    });
+  }
+  addressToBytes(address) {
+    try {
+      const decoded = bech32.bech32m.decode(address);
+      return Array.from(bech32.bech32m.fromWords(decoded.words));
+    } catch {
+      try {
+        const decoded = bech32.bech32.decode(address);
+        return Array.from(bech32.bech32.fromWords(decoded.words));
+      } catch {
+        throw new Error(`Invalid FastSet address: ${address}`);
+      }
     }
   }
 };
-var TransferClaim = class _TransferClaim extends Claim {
-  constructor(recipient, amount, userData) {
-    super();
-    this.type = "Transfer";
-    this.data = { recipient, amount, userData };
+
+// src/WarpFastsetDataLoader.ts
+var WarpFastsetDataLoader = class {
+  constructor(config, chain) {
+    this.config = config;
+    this.chain = chain;
+    this.client = new FastsetClient(config, chain);
   }
-  toTransactionData() {
-    return {
-      Transfer: {
-        recipient: { FastSet: this.data.recipient },
-        amount: this.data.amount,
-        user_data: this.data.userData ?? null
+  addressToBytes(address) {
+    try {
+      const decoded = bech323.bech32m.decode(address);
+      return Array.from(bech323.bech32m.fromWords(decoded.words));
+    } catch {
+      try {
+        const decoded = bech323.bech32.decode(address);
+        return Array.from(bech323.bech32.fromWords(decoded.words));
+      } catch {
+        throw new Error(`Invalid FastSet address: ${address}`);
       }
-    };
+    }
   }
-  static fromData(data) {
-    const recipient = data.recipient.FastSet || data.recipient.External;
-    return new _TransferClaim(recipient, data.amount, data.user_data);
+  async getAccount(address) {
+    const addressBytes = this.addressToBytes(address);
+    const accountInfo = await this.client.getAccountInfo(addressBytes);
+    return { chain: this.chain.name, address, balance: BigInt(accountInfo.balance) };
   }
-  getRecipient() {
-    return this.data.recipient;
+  async getAccountAssets(address) {
+    const addressBytes = this.addressToBytes(address);
+    const accountInfo = await this.client.getAccountInfo(addressBytes);
+    const assets = [];
+    const balance = BigInt(accountInfo.balance);
+    if (balance > 0n) {
+      assets.push({ ...this.chain.nativeToken, amount: balance });
+    }
+    for (const [tokenId, tokenBalance] of accountInfo.token_balance) {
+      const amount = BigInt(tokenBalance);
+      if (amount > 0n) {
+        const tokenInfo = await this.client.getTokenInfo([tokenId]);
+        const metadata = tokenInfo.requested_token_metadata[0]?.[1];
+        assets.push({
+          chain: this.chain.name,
+          identifier: Buffer.from(tokenId).toString("hex"),
+          symbol: metadata?.token_name || "UNKNOWN",
+          name: metadata?.token_name || "Unknown Token",
+          decimals: metadata?.decimals || 6,
+          logoUrl: void 0,
+          amount
+        });
+      }
+    }
+    return assets;
+  }
+  async getAsset(identifier) {
+    const tokenId = Buffer.from(identifier, "hex");
+    const tokenInfo = await this.client.getTokenInfo([Array.from(tokenId)]);
+    const metadata = tokenInfo.requested_token_metadata[0]?.[1];
+    if (!metadata) {
+      return null;
+    }
+    return {
+      chain: this.chain.name,
+      identifier,
+      symbol: metadata.token_name,
+      name: metadata.token_name,
+      decimals: metadata.decimals,
+      logoUrl: void 0,
+      amount: BigInt(metadata.total_supply)
+    };
   }
-  getAmount() {
-    return this.data.amount;
+  async getAction(identifier, awaitCompleted = false) {
+    return null;
   }
-  getUserData() {
-    return this.data.userData;
+  async getAccountActions(address, options) {
+    return [];
   }
 };
 
+// src/WarpFastsetExecutor.ts
+import * as ed25519 from "@noble/ed25519";
+import {
+  getProviderUrl,
+  getWarpActionByIndex
+} from "@vleap/warps";
+
+// src/sdk/Wallet.ts
+import * as bech325 from "bech32";
+
 // src/sdk/ed25519-setup.ts
 import * as ed from "@noble/ed25519";
 import { sha512 } from "@noble/hashes/sha512";
@@ -115,8 +252,9 @@ if (ed.etc) {
 
 // src/sdk/Transaction.ts
 var Transaction = class _Transaction {
-  constructor(sender, nonce, claim, options = {}) {
+  constructor(sender, recipient, nonce, claim, options = {}) {
     this.sender = sender;
+    this.recipient = recipient;
     this.nonce = nonce;
     this.claim = claim;
     this.timestamp = options.timestamp ?? BigInt(Date.now()) * 1000000n;
@@ -124,14 +262,18 @@ var Transaction = class _Transaction {
   toTransaction() {
     return {
       sender: this.sender,
+      recipient: this.recipient,
       nonce: this.nonce,
       timestamp_nanos: this.timestamp,
-      claim: this.claim.toTransactionData()
+      claim: this.claim
     };
   }
   getSender() {
     return this.sender;
   }
+  getRecipient() {
+    return this.recipient;
+  }
   getNonce() {
     return this.nonce;
   }
@@ -142,8 +284,9 @@ var Transaction = class _Transaction {
     return this.timestamp;
   }
   static fromTransaction(transaction) {
-    const claim = Claim.fromTransaction(transaction);
-    return new _Transaction(transaction.sender, transaction.nonce, claim, { timestamp: transaction.timestamp_nanos });
+    return new _Transaction(transaction.sender, transaction.recipient, transaction.nonce, transaction.claim, {
+      timestamp: transaction.timestamp_nanos
+    });
   }
 };
 
@@ -156,8 +299,8 @@ var Wallet = class _Wallet {
     this.publicKeyHex = Buffer.from(this.publicKey).toString("hex");
   }
   toBech32() {
-    const words = bech32.bech32m.toWords(this.publicKey);
-    return bech32.bech32m.encode("set", words);
+    const words = bech325.bech32m.toWords(this.publicKey);
+    return bech325.bech32m.encode("set", words);
   }
   getWalletInfo() {
     return {
@@ -170,27 +313,29 @@ var Wallet = class _Wallet {
     const assetTypeBytes = new TextEncoder().encode(assetType);
     const userData = new Uint8Array(32);
     userData.set(assetTypeBytes.slice(0, 32));
-    return new TransferClaim(recipientBytes, amount.toString(), userData);
-  }
-  createTransaction(nonce, claim) {
-    return new Transaction(this.publicKey, nonce, claim);
+    return {
+      Transfer: {
+        recipient: { FastSet: recipientBytes },
+        amount: amount.toString(),
+        user_data: userData
+      }
+    };
   }
-  async signTransaction(transaction) {
-    const transactionData = transaction.toTransaction();
-    return await TransactionSigner.signTransaction(transactionData, this.privateKey);
+  createTransaction(nonce, recipient, claim) {
+    return new Transaction(this.publicKey, recipient, nonce, claim);
   }
   static decodeBech32Address(address) {
     try {
-      const decoded = bech32.bech32m.decode(address);
-      return new Uint8Array(bech32.bech32m.fromWords(decoded.words));
+      const decoded = bech325.bech32m.decode(address);
+      return new Uint8Array(bech325.bech32m.fromWords(decoded.words));
     } catch (error) {
-      const decoded = bech32.bech32.decode(address);
-      return new Uint8Array(bech32.bech32.fromWords(decoded.words));
+      const decoded = bech325.bech32.decode(address);
+      return new Uint8Array(bech325.bech32.fromWords(decoded.words));
     }
   }
   static encodeBech32Address(publicKey) {
-    const words = bech32.bech32m.toWords(publicKey);
-    return bech32.bech32m.encode("set", words);
+    const words = bech325.bech32m.toWords(publicKey);
+    return bech325.bech32m.encode("set", words);
   }
   static fromPrivateKey(privateKeyHex) {
     return new _Wallet(privateKeyHex);
@@ -207,364 +352,6 @@ var Wallet = class _Wallet {
   }
 };
 
-// src/sdk/FastsetClient.ts
-BigInt.prototype.toJSON = function() {
-  return Number(this);
-};
-var FASTSET_VALIDATOR_URL = "https://rpc.fastset.xyz";
-var FASTSET_PROXY_URL = "http://136.243.61.168:44444";
-var FastsetClient = class {
-  constructor(config) {
-    this.config = config || {
-      validatorUrl: FASTSET_VALIDATOR_URL,
-      proxyUrl: FASTSET_PROXY_URL
-    };
-  }
-  // Generic error handling wrapper for RPC calls
-  async handleRpcCall(method, params, errorMessage, useProxy = false, allowNull = true) {
-    try {
-      const response = useProxy ? await this.requestProxy(method, params) : await this.requestValidator(method, params);
-      console.log(`RPC call to ${method} successful:`, response.result);
-      return response.result;
-    } catch (error) {
-      console.error(`${errorMessage}:`, error);
-      if (!allowNull) throw error;
-      return null;
-    }
-  }
-  async getAccountInfo(address) {
-    const addressBytes = Wallet.decodeBech32Address(address);
-    return this.handleRpcCall("set_getAccountInfo", [Array.from(addressBytes)], `Failed to get account info for address ${address}`);
-  }
-  async getNextNonce(senderAddress) {
-    const accountInfo = await this.getAccountInfo(senderAddress);
-    return accountInfo?.next_nonce ?? 0;
-  }
-  async getAssetBalance(accountId, assetId) {
-    return this.handleRpcCall(
-      "vsl_getAssetBalance",
-      [accountId, assetId],
-      `Failed to get asset balance for account ${accountId}, asset ${assetId}`
-    );
-  }
-  async getAssetBalances(accountId) {
-    return this.handleRpcCall("vsl_getAssetBalances", [accountId], `Failed to get asset balances for account ${accountId}`);
-  }
-  async fundFromFaucet(recipientAddress, amount) {
-    const recipientBytes = Wallet.decodeBech32Address(recipientAddress);
-    return this.handleRpcCall(
-      "faucetDrip",
-      [Array.from(recipientBytes), amount],
-      `Failed to fund from faucet for address ${recipientAddress}`,
-      true,
-      false
-    );
-  }
-  async submitTransaction(request) {
-    const response = await this.handleRpcCall(
-      "set_submitTransaction",
-      [request.transaction, Array.from(request.signature)],
-      "Failed to submit transaction",
-      false,
-      false
-    );
-    const result = response;
-    return {
-      transaction_hash: new Uint8Array(result.transaction_hash),
-      validator: new Uint8Array(result.validator),
-      signature: new Uint8Array(result.signature)
-    };
-  }
-  async submitCertificate(request) {
-    await this.handleRpcCall(
-      "set_submitTransactionCertificate",
-      [
-        request.transaction,
-        Array.from(request.signature),
-        request.validator_signatures.map(([validator, signature]) => [Array.from(validator), Array.from(signature)])
-      ],
-      "Failed to submit certificate",
-      false,
-      false
-    );
-  }
-  async executeTransfer(senderPrivateKey, recipient, amount, userData) {
-    try {
-      console.log(`Executing transfer from sender to ${recipient} for amount ${amount}`);
-      const senderPublicKey = getPublicKey(senderPrivateKey);
-      const senderAddress = Wallet.encodeBech32Address(senderPublicKey);
-      console.log(`Sender address: ${senderAddress}`);
-      const nonce = await this.getNextNonce(senderAddress);
-      console.log(`Using nonce: ${nonce}`);
-      const recipientBytes = Wallet.decodeBech32Address(recipient);
-      console.log(`Recipient decoded successfully`);
-      const transaction = {
-        sender: senderPublicKey,
-        nonce,
-        timestamp_nanos: BigInt(Date.now()) * 1000000n,
-        claim: {
-          Transfer: {
-            recipient: { FastSet: recipientBytes },
-            amount,
-            user_data: userData ?? null
-          }
-        }
-      };
-      console.log("Signing transaction...");
-      const signature = await this.signTransaction(transaction, senderPrivateKey);
-      console.log("Submitting transaction...");
-      const submitResponse = await this.submitTransaction({
-        transaction,
-        signature
-      });
-      console.log("Submitting certificate...");
-      await this.submitCertificate({
-        transaction,
-        signature,
-        validator_signatures: [[submitResponse.validator, submitResponse.signature]]
-      });
-      console.log(`Transfer executed successfully. Transaction hash: ${submitResponse.transaction_hash}`);
-      return submitResponse.transaction_hash;
-    } catch (error) {
-      console.error(`Failed to execute transfer to ${recipient}:`, error);
-      throw error;
-    }
-  }
-  async submitClaim(senderPrivateKey, claim) {
-    try {
-      console.log("Submitting claim...");
-      const senderPublicKey = await getPublicKey(senderPrivateKey);
-      const senderAddress = Wallet.encodeBech32Address(senderPublicKey);
-      console.log(`Claim sender address: ${senderAddress}`);
-      const nonce = await this.getNextNonce(senderAddress);
-      console.log(`Using nonce: ${nonce}`);
-      const transaction = {
-        sender: senderPublicKey,
-        nonce,
-        timestamp_nanos: BigInt(Date.now()) * 1000000n,
-        claim
-      };
-      console.log("Signing claim transaction...");
-      const signature = await this.signTransaction(transaction, senderPrivateKey);
-      console.log("Submitting claim transaction...");
-      const submitResponse = await this.submitTransaction({
-        transaction,
-        signature
-      });
-      console.log("Submitting claim certificate...");
-      await this.submitCertificate({
-        transaction,
-        signature,
-        validator_signatures: [[submitResponse.validator, submitResponse.signature]]
-      });
-      console.log(`Claim submitted successfully. Transaction hash: ${submitResponse.transaction_hash}`);
-      return submitResponse.transaction_hash;
-    } catch (error) {
-      console.error("Failed to submit claim:", error);
-      throw error;
-    }
-  }
-  async signTransaction(transaction, privateKey) {
-    return await TransactionSigner.signTransaction(transaction, privateKey);
-  }
-  async getTransactionStatus(txHash) {
-    return this.handleRpcCall("set_getTransactionStatus", [txHash], `Failed to get transaction status for hash ${txHash}`);
-  }
-  async getTransactionInfo(txHash) {
-    return this.handleRpcCall("set_getTransactionInfo", [txHash], `Failed to get transaction info for hash ${txHash}`);
-  }
-  async getNetworkInfo() {
-    return this.handleRpcCall("set_getNetworkInfo", [], "Failed to get network info");
-  }
-  async requestValidator(method, params) {
-    return this.request(this.config.validatorUrl, method, params);
-  }
-  async requestProxy(method, params) {
-    return this.request(this.config.proxyUrl, method, params);
-  }
-  async request(url, method, params) {
-    try {
-      if (params !== null && params !== void 0) {
-        if (Array.isArray(params)) {
-          for (let i = 0; i < params.length; i++) {
-            if (params[i] === void 0) {
-              throw new Error(`Parameter at index ${i} is undefined`);
-            }
-          }
-        } else if (typeof params === "object") {
-          const paramObj = params;
-          for (const [key, value] of Object.entries(paramObj)) {
-            if (value === void 0) {
-              throw new Error(`Parameter '${key}' is undefined`);
-            }
-          }
-        }
-      }
-      const request = {
-        jsonrpc: "2.0",
-        id: 1,
-        method,
-        params
-      };
-      console.log(`Making RPC request to ${method} with params:`, params);
-      const response = await fetch(url, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify(request, this.jsonReplacer)
-      });
-      if (!response.ok) {
-        throw new Error(`HTTP request failed: ${response.status} ${response.statusText}`);
-      }
-      const jsonResponse = await response.json();
-      if (jsonResponse.error) {
-        throw new Error(`RPC error: ${jsonResponse.error.message} (code: ${jsonResponse.error.code})`);
-      }
-      console.log(`RPC request to ${method} successful:`, jsonResponse.result);
-      return jsonResponse;
-    } catch (error) {
-      console.error(`Fastset RPC request failed for method ${method}:`, error);
-      throw error;
-    }
-  }
-  jsonReplacer(key, value) {
-    if (value instanceof Uint8Array) {
-      return Array.from(value);
-    }
-    return value;
-  }
-};
-
-// src/WarpFastsetDataLoader.ts
-var WarpFastsetDataLoader = class {
-  constructor(config, chain) {
-    this.config = config;
-    this.chain = chain;
-    this.client = new FastsetClient();
-  }
-  async getAccount(address) {
-    const accountInfo = await this.client.getAccountInfo(address);
-    if (!accountInfo) {
-      return {
-        chain: this.chain.name,
-        address,
-        balance: BigInt(0)
-      };
-    }
-    return {
-      chain: this.chain.name,
-      address,
-      balance: BigInt(parseInt(accountInfo.balance, 16))
-    };
-  }
-  async getAccountAssets(address) {
-    const accountReq = this.getAccount(address);
-    const assetBalancesReq = this.client.getAssetBalances(address);
-    const [account, assetBalances] = await Promise.all([accountReq, assetBalancesReq]);
-    const assets = [];
-    if (account.balance > 0) {
-      assets.push({ ...this.chain.nativeToken, amount: account.balance });
-    }
-    if (assetBalances) {
-      for (const [assetId, assetBalance] of Object.entries(assetBalances)) {
-        if (assetBalance.balance) {
-          const amount = BigInt(assetBalance.balance);
-          if (amount > 0) {
-            assets.push({
-              chain: this.chain.name,
-              identifier: assetId,
-              symbol: "TODO: SYMBOL",
-              name: assetBalance.name || assetId,
-              decimals: assetBalance.decimals || 6,
-              logoUrl: assetBalance.logo_url,
-              amount
-            });
-          }
-        }
-      }
-    }
-    return assets;
-  }
-  async getAsset(identifier) {
-    return null;
-  }
-  async getAction(identifier, awaitCompleted = false) {
-    return null;
-  }
-  async getAccountActions(address, options) {
-    return [];
-  }
-  async getAccountInfo(address) {
-    const accountInfo = await this.client.getAccountInfo(address);
-    if (!accountInfo) {
-      return null;
-    }
-    const balanceDecimal = parseInt(accountInfo.balance, 16);
-    return {
-      address,
-      balance: accountInfo.balance,
-      balanceDecimal,
-      nextNonce: accountInfo.next_nonce,
-      sequenceNumber: accountInfo.sequence_number
-    };
-  }
-  async getTransactionInfo(txHash) {
-    return {
-      hash: txHash,
-      hashHex: txHash.startsWith("0x") ? txHash.slice(2) : txHash,
-      status: "submitted",
-      details: {
-        hash: txHash,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      }
-    };
-  }
-  async checkTransferStatus(fromAddress, toAddress, amount) {
-    const fromAccount = await this.getAccountInfo(fromAddress);
-    const toAccount = await this.getAccountInfo(toAddress);
-    if (!fromAccount || !toAccount) {
-      return false;
-    }
-    const transferAmount = parseInt(amount);
-    const fromBalance = fromAccount.balanceDecimal;
-    return fromBalance < transferAmount;
-  }
-  async getAccountBalance(address) {
-    const accountInfo = await this.getAccountInfo(address);
-    if (!accountInfo) {
-      return null;
-    }
-    return {
-      balance: accountInfo.balance,
-      balanceDecimal: accountInfo.balanceDecimal
-    };
-  }
-  async getAssetBalance(address, assetId) {
-    const assetBalance = await this.client.getAssetBalance(address, assetId);
-    if (!assetBalance || !assetBalance.balance) {
-      return null;
-    }
-    const amount = BigInt(assetBalance.balance);
-    if (amount === 0n) {
-      return null;
-    }
-    return {
-      chain: this.chain.name,
-      identifier: assetId,
-      symbol: "TODO: SYMBOL",
-      name: assetBalance.name || assetId,
-      decimals: assetBalance.decimals || 6,
-      logoUrl: assetBalance.logo_url,
-      amount
-    };
-  }
-};
-
-// src/WarpFastsetExecutor.ts
-import {
-  getProviderUrl,
-  getWarpActionByIndex
-} from "@vleap/warps";
-
 // src/WarpFastsetSerializer.ts
 import {
   WarpSerializer
@@ -683,10 +470,8 @@ var WarpFastsetExecutor = class {
     this.config = config;
     this.chain = chain;
     this.serializer = new WarpFastsetSerializer();
-    const validatorUrl = getProviderUrl(this.config, chain.name, this.config.env, this.chain.defaultApiUrl);
     const proxyUrl = getProviderUrl(this.config, chain.name, this.config.env, this.chain.defaultApiUrl);
     this.fastsetClient = new FastsetClient({
-      validatorUrl,
       proxyUrl
     });
   }
@@ -783,6 +568,17 @@ var WarpFastsetExecutor = class {
   async signMessage(message, privateKey) {
     throw new Error("Not implemented");
   }
+  async signTransaction(transaction, privateKey) {
+    const transactionJson = JSON.stringify(transaction, (key, value) => {
+      if (value instanceof Uint8Array) {
+        return Array.from(value);
+      }
+      return value;
+    });
+    const prefix = "Transaction::";
+    const dataToSign = new TextEncoder().encode(prefix + transactionJson);
+    return await ed25519.sign(dataToSign, privateKey);
+  }
   async executeTransfer(executable) {
     const userWallet = this.config.user?.wallets?.[executable.chain.name];
     if (!userWallet) throw new Error("WarpFastsetExecutor: executeTransfer - user wallet not set");
@@ -799,12 +595,22 @@ var WarpFastsetExecutor = class {
     if (!userWallet) throw new Error("WarpFastsetExecutor: executeTransfer - user wallet not set");
     const transaction = await this.createTransferTransaction(executable);
     const privateKeyBytes = this.fromBase64(privateKey);
-    const transactionHash = await this.fastsetClient.executeTransfer(
-      privateKeyBytes,
-      transaction.recipient,
-      transaction.amount,
-      transaction.userData
-    );
+    const transactionData = {
+      sender: Array.from(privateKeyBytes.slice(0, 32)),
+      // First 32 bytes as public key
+      recipient: { FastSet: transaction.recipient },
+      nonce: await this.fastsetClient.getNextNonce(Wallet.encodeBech32Address(privateKeyBytes.slice(0, 32))),
+      timestamp_nanos: (BigInt(Date.now()) * 1000000n).toString(),
+      claim: {
+        Transfer: {
+          recipient: { FastSet: transaction.recipient },
+          amount: transaction.amount,
+          user_data: transaction.userData ? Array.from(transaction.userData) : null
+        }
+      }
+    };
+    const signature = await this.signTransaction(transactionData, privateKeyBytes);
+    const transactionHash = await this.fastsetClient.submitTransaction(transactionData, signature);
     return {
       success: true,
       transactionHash: Array.from(transactionHash),
@@ -1028,21 +834,8 @@ var getFastsetAdapter = createFastsetAdapter(WarpChainName.Fastset, "fastset", {
   }
 });
 export {
-  Address,
-  Amount,
-  BcsTransaction,
-  Bytes32,
-  Claim,
-  ClaimType,
   FastsetClient,
   NativeTokenSet,
-  Nonce,
-  PublicKey,
-  Transaction,
-  Transfer,
-  TransferClaim,
-  UserData,
-  Wallet,
   WarpFastsetConstants,
   WarpFastsetDataLoader,
   WarpFastsetExecutor,