@vleap/warps-adapter-fastset 0.1.0-alpha.12 → 0.1.0-alpha.14

package/dist/index.mjs

@@ -1,118 +1,16 @@
 // src/constants.ts
 var WarpFastsetConstants = {
-  Pi: {
-    Identifier: "PI",
-    DisplayName: "Pi",
-    Decimals: 18
-  },
-  GasLimit: {
-    Default: 21e3,
-    ContractCall: 1e5,
-    ContractDeploy: 5e5,
-    Transfer: 21e3,
-    Approve: 46e3,
-    Swap: 2e5
-  },
-  GasPrice: {
-    Default: "20000000000",
-    // 20 gwei
-    Low: "10000000000",
-    // 10 gwei
-    Medium: "20000000000",
-    // 20 gwei
-    High: "50000000000"
-    // 50 gwei
-  },
-  Validation: {
-    AddressLength: 42,
-    HexPrefix: "0x",
-    MinGasLimit: 21e3,
-    MaxGasLimit: 3e7
-  },
-  Timeouts: {
-    DefaultRpcTimeout: 3e4,
-    // 30 seconds
-    GasEstimationTimeout: 1e4,
-    // 10 seconds
-    QueryTimeout: 15e3
-    // 15 seconds
-  }
-};
-
-// src/WarpFastsetDataLoader.ts
-var WarpFastsetDataLoader = class {
-  constructor(config, chain) {
-    this.config = config;
-    this.chain = chain;
-  }
-  async getAccount(address) {
-    return {
-      address,
-      balance: BigInt(0)
-      // TODO: Implement actual balance fetching from Fastset API
-    };
-  }
-  async getAccountAssets(address) {
-    return [];
-  }
+  // Placeholder for future FastSet-specific constants
 };
 
-// src/WarpFastsetExecutor.ts
-import {
-  getProviderUrl,
-  getWarpActionByIndex
-} from "@vleap/warps";
-
-// src/config.ts
-var FASTSET_CHAIN_CONFIGS = {
-  fastset: {
-    mainnet: {
-      defaultApiUrl: "http://157.90.201.117:8765",
-      proxyUrl: "http://136.243.61.168:44444",
-      explorerUrl: "https://explorer.fastset.com",
-      chainId: "1",
-      registryAddress: "0x0000000000000000000000000000000000000000",
-      nativeToken: "PI",
-      blockTime: 12e3
-    },
-    testnet: {
-      defaultApiUrl: "http://157.90.201.117:8765",
-      proxyUrl: "http://136.243.61.168:44444",
-      explorerUrl: "https://testnet-explorer.fastset.com",
-      chainId: "11155111",
-      registryAddress: "0x0000000000000000000000000000000000000000",
-      nativeToken: "PI",
-      blockTime: 12e3
-    },
-    devnet: {
-      defaultApiUrl: "http://157.90.201.117:8765",
-      proxyUrl: "http://136.243.61.168:44444",
-      explorerUrl: "http://localhost:4000",
-      chainId: "1337",
-      registryAddress: "0x0000000000000000000000000000000000000000",
-      nativeToken: "PI",
-      blockTime: 12e3
-    }
-  }
-};
-var DEFAULT_CHAIN = "fastset";
-var getFastsetChainConfig = (chain = DEFAULT_CHAIN, env) => {
-  const chainConfigs = FASTSET_CHAIN_CONFIGS[chain];
-  if (!chainConfigs) {
-    throw new Error(`Unsupported Fastset chain: ${chain}`);
-  }
-  const config = chainConfigs[env];
-  if (!config) {
-    throw new Error(`Unsupported environment ${env} for chain ${chain}`);
-  }
-  return config;
-};
-var getFastsetApiUrl = (env, chain = DEFAULT_CHAIN) => {
-  return getFastsetChainConfig(chain, env).apiUrl;
-};
+// src/main.ts
+import { WarpChainName } from "@vleap/warps";
 
 // src/sdk/FastsetClient.ts
-import { getPublicKey, sign } from "@noble/ed25519";
+import { getPublicKey } from "@noble/ed25519";
+
+// src/sdk/TransactionSigner.ts
+import { sign } from "@noble/ed25519";
 
 // src/sdk/types.ts
 import { bcs } from "@mysten/bcs";
@@ -139,7 +37,7 @@ var Transfer = bcs.struct("Transfer", {
 var ClaimType = bcs.enum("ClaimType", {
   Transfer
 });
-var Transaction = bcs.struct("Transaction", {
+var BcsTransaction = bcs.struct("Transaction", {
   sender: PublicKey,
   nonce: Nonce,
   timestamp_nanos: bcs.u128(),
@@ -149,15 +47,179 @@ 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);
+  }
+};
+
+// 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}`);
+    }
+  }
+};
+var TransferClaim = class _TransferClaim extends Claim {
+  constructor(recipient, amount, userData) {
+    super();
+    this.type = "Transfer";
+    this.data = { recipient, amount, userData };
+  }
+  toTransactionData() {
+    return {
+      Transfer: {
+        recipient: { FastSet: this.data.recipient },
+        amount: this.data.amount,
+        user_data: this.data.userData ?? null
+      }
+    };
+  }
+  static fromData(data) {
+    const recipient = data.recipient.FastSet || data.recipient.External;
+    return new _TransferClaim(recipient, data.amount, data.user_data);
+  }
+  getRecipient() {
+    return this.data.recipient;
+  }
+  getAmount() {
+    return this.data.amount;
+  }
+  getUserData() {
+    return this.data.userData;
+  }
+};
+
+// src/sdk/ed25519-setup.ts
+import * as ed from "@noble/ed25519";
+import { sha512 } from "@noble/hashes/sha512";
+if (ed.etc) {
+  ed.etc.sha512Sync = (...m) => sha512(ed.etc.concatBytes(...m));
+}
+
+// src/sdk/Transaction.ts
+var Transaction = class _Transaction {
+  constructor(sender, nonce, claim, options = {}) {
+    this.sender = sender;
+    this.nonce = nonce;
+    this.claim = claim;
+    this.timestamp = options.timestamp ?? BigInt(Date.now()) * 1000000n;
+  }
+  toTransaction() {
+    return {
+      sender: this.sender,
+      nonce: this.nonce,
+      timestamp_nanos: this.timestamp,
+      claim: this.claim.toTransactionData()
+    };
+  }
+  getSender() {
+    return this.sender;
+  }
+  getNonce() {
+    return this.nonce;
+  }
+  getClaim() {
+    return this.claim;
+  }
+  getTimestamp() {
+    return this.timestamp;
+  }
+  static fromTransaction(transaction) {
+    const claim = Claim.fromTransaction(transaction);
+    return new _Transaction(transaction.sender, transaction.nonce, claim, { timestamp: transaction.timestamp_nanos });
+  }
+};
+
+// src/sdk/Wallet.ts
+var Wallet = class _Wallet {
+  constructor(privateKeyHex) {
+    const cleanPrivateKey = privateKeyHex.replace(/^0x/, "");
+    this.privateKey = Buffer.from(cleanPrivateKey, "hex");
+    this.publicKey = ed.getPublicKey(this.privateKey);
+    this.publicKeyHex = Buffer.from(this.publicKey).toString("hex");
+  }
+  toBech32() {
+    const words = bech32.bech32m.toWords(this.publicKey);
+    return bech32.bech32m.encode("set", words);
+  }
+  getWalletInfo() {
+    return {
+      publicKeyHex: this.publicKeyHex,
+      address: this.toBech32()
+    };
+  }
+  createTransferClaim(recipientAddress, amount, assetType) {
+    const recipientBytes = _Wallet.decodeBech32Address(recipientAddress);
+    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);
+  }
+  async signTransaction(transaction) {
+    const transactionData = transaction.toTransaction();
+    return await TransactionSigner.signTransaction(transactionData, this.privateKey);
+  }
+  static decodeBech32Address(address) {
+    try {
+      const decoded = bech32.bech32m.decode(address);
+      return new Uint8Array(bech32.bech32m.fromWords(decoded.words));
+    } catch (error) {
+      const decoded = bech32.bech32.decode(address);
+      return new Uint8Array(bech32.bech32.fromWords(decoded.words));
+    }
+  }
+  static encodeBech32Address(publicKey) {
+    const words = bech32.bech32m.toWords(publicKey);
+    return bech32.bech32m.encode("set", words);
+  }
+  static fromPrivateKey(privateKeyHex) {
+    return new _Wallet(privateKeyHex);
+  }
+  static generateNew() {
+    const privateKey = ed.utils.randomPrivateKey();
+    const privateKeyHex = Buffer.from(privateKey).toString("hex");
+    return new _Wallet(privateKeyHex);
+  }
+  static async fromPrivateKeyFile(filePath) {
+    const fs = await import("fs/promises");
+    const privateKeyHex = (await fs.readFile(filePath, "utf8")).trim();
+    return new _Wallet(privateKeyHex);
+  }
+};
+
 // src/sdk/FastsetClient.ts
+BigInt.prototype.toJSON = function() {
+  return Number(this);
+};
 var FastsetClient = class {
   constructor(config) {
     this.config = config;
   }
   async getAccountInfo(address) {
     try {
+      const addressBytes = Wallet.decodeBech32Address(address);
       const response = await this.requestValidator("set_getAccountInfo", {
-        address: Array.from(address)
+        address: Array.from(addressBytes)
       });
       if (response.error) {
         return null;
@@ -171,10 +233,11 @@ var FastsetClient = class {
     const accountInfo = await this.getAccountInfo(senderAddress);
     return accountInfo?.next_nonce ?? 0;
   }
-  async fundFromFaucet(request) {
+  async fundFromFaucet(recipientAddress, amount) {
+    const recipientBytes = Wallet.decodeBech32Address(recipientAddress);
     const response = await this.requestProxy("faucetDrip", {
-      recipient: Array.from(request.recipient),
-      amount: request.amount
+      recipient: Array.from(recipientBytes),
+      amount
     });
     if (response.error) {
       throw new Error(`Faucet request failed: ${response.error.message}`);
@@ -183,7 +246,7 @@ var FastsetClient = class {
   }
   async submitTransaction(request) {
     const response = await this.requestValidator("set_submitTransaction", {
-      transaction: this.serializeTransaction(request.transaction),
+      transaction: request.transaction,
       signature: Array.from(request.signature)
     });
     if (response.error) {
@@ -198,7 +261,7 @@ var FastsetClient = class {
   }
   async submitCertificate(request) {
     const response = await this.requestValidator("set_submitTransactionCertificate", {
-      transaction: this.serializeTransaction(request.transaction),
+      transaction: request.transaction,
       signature: Array.from(request.signature),
       validator_signatures: request.validator_signatures.map(([validator, signature]) => [Array.from(validator), Array.from(signature)])
     });
@@ -208,14 +271,16 @@ var FastsetClient = class {
   }
   async executeTransfer(senderPrivateKey, recipient, amount, userData) {
     const senderPublicKey = await getPublicKey(senderPrivateKey);
-    const nonce = await this.getNextNonce(senderPublicKey);
+    const senderAddress = Wallet.encodeBech32Address(senderPublicKey);
+    const nonce = await this.getNextNonce(senderAddress);
+    const recipientBytes = Wallet.decodeBech32Address(recipient);
     const transaction = {
       sender: senderPublicKey,
       nonce,
       timestamp_nanos: BigInt(Date.now()) * 1000000n,
       claim: {
         Transfer: {
-          recipient: { FastSet: recipient },
+          recipient: { FastSet: recipientBytes },
           amount,
           user_data: userData ?? null
         }
@@ -233,17 +298,67 @@ var FastsetClient = class {
     });
     return submitResponse.transaction_hash;
   }
+  async submitClaim(senderPrivateKey, claim) {
+    const senderPublicKey = await getPublicKey(senderPrivateKey);
+    const senderAddress = Wallet.encodeBech32Address(senderPublicKey);
+    const nonce = await this.getNextNonce(senderAddress);
+    const transaction = {
+      sender: senderPublicKey,
+      nonce,
+      timestamp_nanos: BigInt(Date.now()) * 1000000n,
+      claim
+    };
+    const signature = await this.signTransaction(transaction, senderPrivateKey);
+    const submitResponse = await this.submitTransaction({
+      transaction,
+      signature
+    });
+    await this.submitCertificate({
+      transaction,
+      signature,
+      validator_signatures: [[submitResponse.validator, submitResponse.signature]]
+    });
+    return submitResponse.transaction_hash;
+  }
   async signTransaction(transaction, privateKey) {
-    const msg = Transaction.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);
+    return await TransactionSigner.signTransaction(transaction, privateKey);
+  }
+  async getTransactionStatus(txHash) {
+    try {
+      const response = await this.requestValidator("set_getTransactionStatus", {
+        hash: txHash
+      });
+      if (response.error) {
+        return null;
+      }
+      return response.result;
+    } catch (error) {
+      return null;
+    }
   }
-  serializeTransaction(transaction) {
-    return JSON.stringify(transaction, this.jsonReplacer);
+  async getTransactionInfo(txHash) {
+    try {
+      const response = await this.requestValidator("set_getTransactionInfo", {
+        hash: txHash
+      });
+      if (response.error) {
+        return null;
+      }
+      return response.result;
+    } catch (error) {
+      return null;
+    }
+  }
+  async getNetworkInfo() {
+    try {
+      const response = await this.requestValidator("set_getNetworkInfo", {});
+      if (response.error) {
+        return null;
+      }
+      return response.result;
+    } catch (error) {
+      return null;
+    }
   }
   async requestValidator(method, params) {
     return this.request(this.config.validatorUrl, method, params);
@@ -276,69 +391,131 @@ var FastsetClient = class {
   }
 };
 
-// src/sdk/utils.ts
-import { toB64, toHEX } from "@mysten/bcs";
-function isValidFastsetAddress(address) {
-  if (typeof address !== "string" || address.length === 0) {
-    return false;
+// src/WarpFastsetDataLoader.ts
+var WarpFastsetDataLoader = class {
+  constructor(config, chain) {
+    this.config = config;
+    this.chain = chain;
+    const validatorUrl = this.chain.defaultApiUrl;
+    const proxyUrl = this.chain.defaultApiUrl;
+    this.client = new FastsetClient({
+      validatorUrl,
+      proxyUrl
+    });
   }
-  if (address.startsWith("fs") || address.startsWith("pi")) {
-    return true;
+  async getAccount(address) {
+    try {
+      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))
+      };
+    } catch (error) {
+      return {
+        chain: this.chain.name,
+        address,
+        balance: BigInt(0)
+      };
+    }
   }
-  try {
-    const decoded = fromBase64(address);
-    return decoded.length === 32;
-  } catch {
-    return false;
+  async getAccountAssets(address) {
+    try {
+      const account = await this.getAccount(address);
+      if (account.balance > 0) {
+        return [
+          {
+            chain: this.chain.name,
+            identifier: this.chain.nativeToken?.identifier || "SET",
+            name: this.chain.nativeToken?.name || "SET",
+            decimals: this.chain.nativeToken?.decimals || 6,
+            amount: account.balance,
+            logoUrl: this.chain.nativeToken?.logoUrl
+          }
+        ];
+      }
+      return [];
+    } catch (error) {
+      return [];
+    }
   }
-}
-function fromBase64(base64) {
-  return new Uint8Array(Buffer.from(base64, "base64"));
-}
-function toBase64String(bytes) {
-  return toB64(bytes);
-}
-function toHexString(bytes) {
-  return toHEX(bytes);
-}
-function hexToDecimal2(hex) {
-  return BigInt(`0x${hex}`).toString();
-}
-function decimalToHex(decimal) {
-  return BigInt(decimal).toString(16);
-}
-function validateAmount(amount) {
-  try {
-    const bigInt = BigInt(amount);
-    return bigInt >= 0;
-  } catch {
-    return false;
+  async getAccountActions(address, options) {
+    return [];
   }
-}
-function normalizeAmount(amount) {
-  try {
-    const bigInt = BigInt(amount);
-    return bigInt.toString(16);
-  } catch {
-    throw new Error(`Invalid amount format: ${amount}`);
+  async getAccountInfo(address) {
+    try {
+      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
+      };
+    } catch (error) {
+      console.error("Error getting account info:", error);
+      return null;
+    }
   }
-}
-function validatePrivateKey(privateKey) {
-  try {
-    const key = typeof privateKey === "string" ? fromBase64(privateKey) : privateKey;
-    return key.length === 32;
-  } catch {
-    return false;
+  async getTransactionInfo(txHash) {
+    try {
+      return {
+        hash: txHash,
+        hashHex: txHash.startsWith("0x") ? txHash.slice(2) : txHash,
+        status: "submitted",
+        details: {
+          hash: txHash,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      };
+    } catch (error) {
+      console.error("Error getting transaction info:", error);
+      return null;
+    }
   }
-}
-function validatePublicKey(publicKey) {
-  try {
-    const key = typeof publicKey === "string" ? fromBase64(publicKey) : publicKey;
-    return key.length === 32;
-  } catch {
-    return false;
+  async checkTransferStatus(fromAddress, toAddress, amount) {
+    try {
+      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;
+    } catch (error) {
+      console.error("Error checking transfer status:", error);
+      return false;
+    }
   }
-}
+  async getAccountBalance(address) {
+    const accountInfo = await this.getAccountInfo(address);
+    if (!accountInfo) {
+      return null;
+    }
+    return {
+      balance: accountInfo.balance,
+      balanceDecimal: accountInfo.balanceDecimal
+    };
+  }
+};
+
+// src/WarpFastsetExecutor.ts
+import {
+  getProviderUrl,
+  getWarpActionByIndex
+} from "@vleap/warps";
 
 // src/WarpFastsetSerializer.ts
 import {
@@ -359,7 +536,7 @@ var WarpFastsetSerializer = class {
       return `boolean:${value}`;
     }
     if (typeof value === "bigint") {
-      return `bigint:${value.toString()}`;
+      return `biguint:${value.toString()}`;
     }
     if (Array.isArray(value)) {
       const items = value.map((item) => this.typedToString(item)).join(",");
@@ -384,7 +561,7 @@ var WarpFastsetSerializer = class {
       return ["boolean", value];
     }
     if (typeof value === "bigint") {
-      return ["bigint", value];
+      return ["biguint", value.toString()];
     }
     return ["string", String(value)];
   }
@@ -396,8 +573,12 @@ var WarpFastsetSerializer = class {
         return Number(value);
       case "boolean":
         return Boolean(value);
-      case "bigint":
+      case "biguint":
         return BigInt(value);
+      case "address":
+        return String(value);
+      case "hex":
+        return String(value);
       default:
         return String(value);
     }
@@ -410,8 +591,12 @@ var WarpFastsetSerializer = class {
         return "number";
       case "boolean":
         return "boolean";
-      case "bigint":
-        return "bigint";
+      case "biguint":
+        return "biguint";
+      case "address":
+        return "address";
+      case "hex":
+        return "hex";
       default:
         return "string";
     }
@@ -430,7 +615,7 @@ var WarpFastsetSerializer = class {
         return Number(stringValue);
       case "boolean":
         return stringValue === "true";
-      case "bigint":
+      case "biguint":
         return BigInt(stringValue);
       case "array":
         return stringValue.split(",").map((item) => this.stringToTyped(item));
@@ -450,10 +635,10 @@ var WarpFastsetExecutor = class {
     this.config = config;
     this.chain = chain;
     this.serializer = new WarpFastsetSerializer();
-    const apiUrl = getProviderUrl(this.config, chain.name, this.config.env, this.chain.defaultApiUrl);
+    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: apiUrl,
+      validatorUrl,
       proxyUrl
     });
   }
@@ -475,15 +660,15 @@ var WarpFastsetExecutor = class {
   async createTransferTransaction(executable) {
     const userWallet = this.config.user?.wallets?.[executable.chain.name];
     if (!userWallet) throw new Error("WarpFastsetExecutor: createTransfer - user address not set");
-    if (!isValidFastsetAddress(executable.destination)) {
+    if (!this.isValidFastsetAddress(executable.destination)) {
       throw new Error(`WarpFastsetExecutor: Invalid destination address: ${executable.destination}`);
     }
     if (executable.value < 0) {
       throw new Error(`WarpFastsetExecutor: Transfer value cannot be negative: ${executable.value}`);
     }
-    const recipientAddress = fromBase64(executable.destination);
-    const amount = normalizeAmount(executable.value.toString());
-    const userData = executable.data ? fromBase64(this.serializer.stringToTyped(executable.data)) : void 0;
+    const recipientAddress = this.fromBase64(executable.destination);
+    const amount = this.normalizeAmount(executable.value.toString());
+    const userData = executable.data ? this.fromBase64(this.serializer.stringToTyped(executable.data)) : void 0;
     return {
       type: "fastset-transfer",
       recipient: recipientAddress,
@@ -499,14 +684,14 @@ var WarpFastsetExecutor = class {
     if (!action || !("func" in action) || !action.func) {
       throw new Error("WarpFastsetExecutor: Contract action must have a function name");
     }
-    if (!isValidFastsetAddress(executable.destination)) {
+    if (!this.isValidFastsetAddress(executable.destination)) {
       throw new Error(`WarpFastsetExecutor: Invalid contract address: ${executable.destination}`);
     }
     if (executable.value < 0) {
       throw new Error(`WarpFastsetExecutor: Contract call value cannot be negative: ${executable.value}`);
     }
     try {
-      const contractAddress = fromBase64(executable.destination);
+      const contractAddress = this.fromBase64(executable.destination);
       const encodedData = this.encodeFunctionData(action.func, executable.args);
       return {
         type: "fastset-contract-call",
@@ -528,11 +713,11 @@ var WarpFastsetExecutor = class {
     if (!action.func) {
       throw new Error("WarpFastsetExecutor: Query action must have a function name");
     }
-    if (!isValidFastsetAddress(executable.destination)) {
+    if (!this.isValidFastsetAddress(executable.destination)) {
       throw new Error(`WarpFastsetExecutor: Invalid contract address for query: ${executable.destination}`);
     }
     try {
-      const contractAddress = fromBase64(executable.destination);
+      const contractAddress = this.fromBase64(executable.destination);
       const result = await this.executeFastsetQuery(contractAddress, action.func, executable.args);
       return {
         success: true,
@@ -548,57 +733,7 @@ var WarpFastsetExecutor = class {
     }
   }
   async preprocessInput(chain, input, type, value) {
-    const typedValue = this.serializer.stringToTyped(value);
-    switch (type) {
-      case "address":
-        if (!isValidFastsetAddress(typedValue)) {
-          throw new Error(`Invalid Fastset address format: ${typedValue}`);
-        }
-        return typedValue;
-      case "hex":
-        const hexValue = typedValue.startsWith("0x") ? typedValue.slice(2) : typedValue;
-        if (!/^[0-9a-fA-F]+$/.test(hexValue)) {
-          throw new Error(`Invalid hex format: ${typedValue}`);
-        }
-        return typedValue;
-      case "number":
-        const numValue = Number(typedValue);
-        if (isNaN(numValue)) {
-          throw new Error(`Invalid number format: ${typedValue}`);
-        }
-        return numValue.toString();
-      case "biguint":
-        const bigIntValue = BigInt(typedValue);
-        if (bigIntValue < 0) {
-          throw new Error(`Negative value not allowed`);
-        }
-        return bigIntValue.toString();
-      default:
-        return String(typedValue);
-    }
-  }
-  encodeFunctionData(functionName, args) {
-    return JSON.stringify({
-      function: functionName,
-      arguments: args
-    });
-  }
-  async executeFastsetQuery(contractAddress, functionName, args) {
-    const response = await fetch(`${getFastsetApiUrl(this.config.env, "fastset")}/query`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
-        contract: Array.from(contractAddress),
-        function: functionName,
-        arguments: args
-      })
-    });
-    if (!response.ok) {
-      throw new Error(`Fastset query failed: ${response.statusText}`);
-    }
-    return response.json();
+    return value;
   }
   async signMessage(message, privateKey) {
     throw new Error("Not implemented");
@@ -618,7 +753,7 @@ var WarpFastsetExecutor = class {
     const userWallet = this.config.user?.wallets?.[executable.chain.name];
     if (!userWallet) throw new Error("WarpFastsetExecutor: executeTransfer - user wallet not set");
     const transaction = await this.createTransferTransaction(executable);
-    const privateKeyBytes = fromBase64(privateKey);
+    const privateKeyBytes = this.fromBase64(privateKey);
     const transactionHash = await this.fastsetClient.executeTransfer(
       privateKeyBytes,
       transaction.recipient,
@@ -631,35 +766,70 @@ var WarpFastsetExecutor = class {
       chain: executable.chain.name
     };
   }
+  encodeFunctionData(functionName, args) {
+    return JSON.stringify({
+      function: functionName,
+      arguments: args
+    });
+  }
+  async executeFastsetQuery(contractAddress, functionName, args) {
+    const validatorUrl = getProviderUrl(this.config, this.chain.name, this.config.env, this.chain.defaultApiUrl);
+    const response = await fetch(`${validatorUrl}/query`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        contract: Array.from(contractAddress),
+        function: functionName,
+        arguments: args
+      })
+    });
+    if (!response.ok) {
+      throw new Error(`Fastset query failed: ${response.statusText}`);
+    }
+    return response.json();
+  }
+  isValidFastsetAddress(address) {
+    if (typeof address !== "string" || address.length === 0) {
+      return false;
+    }
+    if (address.startsWith("fs") || address.startsWith("pi")) {
+      return true;
+    }
+    try {
+      const decoded = this.fromBase64(address);
+      return decoded.length === 32;
+    } catch {
+      return false;
+    }
+  }
+  fromBase64(base64) {
+    return Uint8Array.from(atob(base64), (c) => c.charCodeAt(0));
+  }
+  normalizeAmount(amount) {
+    return amount.startsWith("0x") ? amount.slice(2) : amount;
+  }
 };
 
 // src/WarpFastsetExplorer.ts
 var WarpFastsetExplorer = class {
-  constructor(chainInfo) {
-    this.chainInfo = chainInfo;
+  constructor(_chainInfo, _config) {
+    this._chainInfo = _chainInfo;
+    this._config = _config;
+    this.explorerUrl = "https://explorer.fastset.xyz";
   }
   getAccountUrl(address) {
-    const baseUrl = this.getDefaultExplorerUrl();
-    return `${baseUrl}/address/${address}`;
+    return `${this.explorerUrl}/account/${address}`;
   }
   getTransactionUrl(hash) {
-    const baseUrl = this.getDefaultExplorerUrl();
-    return `${baseUrl}/tx/${hash}`;
-  }
-  getBlockUrl(blockNumber) {
-    const baseUrl = this.getDefaultExplorerUrl();
-    return `${baseUrl}/block/${blockNumber}`;
-  }
-  getContractUrl(address) {
-    const baseUrl = this.getDefaultExplorerUrl();
-    return `${baseUrl}/contract/${address}`;
+    return `${this.explorerUrl}/transaction/${hash}`;
   }
   getAssetUrl(identifier) {
-    const baseUrl = this.getDefaultExplorerUrl();
-    return `${baseUrl}/token/${identifier}`;
+    return `${this.explorerUrl}/asset/${identifier}`;
   }
-  getDefaultExplorerUrl() {
-    return `https://explorer.fastset.xyz`;
+  getContractUrl(address) {
+    return `${this.explorerUrl}/account/${address}`;
   }
 };
 
@@ -670,26 +840,26 @@ import {
   WarpConstants
 } from "@vleap/warps";
 var WarpFastsetResults = class {
-  constructor(config) {
+  constructor(config, chain) {
     this.config = config;
+    this.chain = chain;
     this.serializer = new WarpFastsetSerializer();
   }
   async getTransactionExecutionResults(warp, tx) {
     const success = this.isTransactionSuccessful(tx);
-    const gasUsed = this.extractGasUsed(tx);
-    const gasPrice = this.extractGasPrice(tx);
-    const blockNumber = this.extractBlockNumber(tx);
     const transactionHash = this.extractTransactionHash(tx);
-    const logs = this.extractLogs(tx);
+    const blockNumber = this.extractBlockNumber(tx);
+    const timestamp = this.extractTimestamp(tx);
     return {
       success,
       warp,
       action: 0,
-      user: this.config.user?.wallets?.fastset || null,
+      user: this.config.user?.wallets?.[this.chain.name] || null,
       txHash: transactionHash,
       tx,
       next: null,
-      values: [transactionHash, blockNumber, gasUsed, gasPrice, ...logs.length > 0 ? logs : []],
+      values: [transactionHash, blockNumber, timestamp],
+      valuesRaw: [transactionHash, blockNumber, timestamp],
       results: {},
       messages: {}
     };
@@ -700,6 +870,11 @@ var WarpFastsetResults = class {
     let results = {};
     if (!warp.results) return { values, results };
     const getNestedValue = (path) => {
+      const match = path.match(/^out\[(\d+)\]$/);
+      if (match) {
+        const index = parseInt(match[1]) - 1;
+        return valuesRaw[index];
+      }
       const indices = path.split(".").slice(1).map((i) => parseInt(i) - 1);
       if (indices.length === 0) return void 0;
       let value = valuesRaw[indices[0]];
@@ -717,7 +892,8 @@ var WarpFastsetResults = class {
         continue;
       }
       if (path.startsWith("out.") || path === "out" || path.startsWith("out[")) {
-        results[key] = getNestedValue(path) || null;
+        const value = getNestedValue(path);
+        results[key] = value || null;
       } else {
         results[key] = path;
       }
@@ -725,87 +901,108 @@ var WarpFastsetResults = class {
     return { values, results: await evaluateResultsCommon(warp, results, actionIndex, inputs, this.config.transform?.runner) };
   }
   isTransactionSuccessful(tx) {
-    return tx.status === "success" || tx.status === 1 || tx.success === true;
-  }
-  extractGasUsed(tx) {
-    return tx.gasUsed?.toString() || tx.gas_used?.toString() || "0";
+    if (!tx) return false;
+    if (tx.success === false) return false;
+    if (tx.success === true) return true;
+    if (tx.status === "success") return true;
+    if (tx.status === 1) return true;
+    if (tx.result && tx.result.success === true) return true;
+    return false;
   }
-  extractGasPrice(tx) {
-    return tx.gasPrice?.toString() || tx.gas_price?.toString() || "0";
+  extractTransactionHash(tx) {
+    if (!tx) return "";
+    return tx.transaction_hash || tx.transactionHash || tx.hash || tx.result && tx.result.transaction_hash || "";
   }
   extractBlockNumber(tx) {
-    return tx.blockNumber?.toString() || tx.block_number?.toString() || "0";
+    if (!tx) return "0";
+    return tx.block_number?.toString() || tx.blockNumber?.toString() || tx.result && tx.result.block_number?.toString() || "0";
   }
-  extractTransactionHash(tx) {
-    return tx.hash || tx.transactionHash || tx.transaction_hash || "";
-  }
-  extractLogs(tx) {
-    const logs = tx.logs || tx.events || [];
-    return logs.map((log) => ({
-      address: log.address || log.contract,
-      topics: log.topics || log.topics || [],
-      data: log.data || log.payload || "",
-      blockNumber: log.blockNumber?.toString() || log.block_number?.toString() || "0",
-      transactionHash: log.transactionHash || log.transaction_hash || "",
-      index: log.index?.toString() || "0"
-    }));
+  extractTimestamp(tx) {
+    if (!tx) return "0";
+    return tx.timestamp?.toString() || tx.timestamp_nanos?.toString() || tx.result && tx.result.timestamp?.toString() || Date.now().toString();
   }
 };
 
 // src/main.ts
-var ChainName = "fastset";
-var getFastsetAdapter = (config, fallback) => {
-  if (!fallback) throw new Error("Fastset adapter requires a fallback adapter");
-  const chainInfo = {
-    name: ChainName,
+var NativeTokenSet = {
+  chain: WarpChainName.Fastset,
+  identifier: "SET",
+  name: "SET",
+  decimals: 6,
+  logoUrl: "https://vleap.ai/images/tokens/set.svg"
+};
+function createFastsetAdapter(chainName, chainPrefix, chainInfos) {
+  return (config, fallback) => {
+    const chainInfo = chainInfos[config.env];
+    if (!chainInfo) throw new Error(`FastsetAdapter: chain info not found for chain ${chainName}`);
+    if (!fallback) throw new Error("Fastset adapter requires a fallback adapter");
+    return {
+      chain: chainName,
+      chainInfo,
+      prefix: chainPrefix,
+      builder: () => fallback.builder(),
+      executor: new WarpFastsetExecutor(config, chainInfo),
+      results: new WarpFastsetResults(config, chainInfo),
+      serializer: new WarpFastsetSerializer(),
+      registry: fallback.registry,
+      explorer: new WarpFastsetExplorer(chainInfo, config),
+      abiBuilder: () => fallback.abiBuilder(),
+      brandBuilder: () => fallback.brandBuilder(),
+      dataLoader: new WarpFastsetDataLoader(config, chainInfo)
+    };
+  };
+}
+var getFastsetAdapter = createFastsetAdapter(WarpChainName.Fastset, "fastset", {
+  mainnet: {
+    name: WarpChainName.Fastset,
     displayName: "FastSet",
     chainId: "1",
-    blockTime: 100,
+    blockTime: 1e3,
     addressHrp: "set",
-    defaultApiUrl: "TODO",
-    nativeToken: "SET"
-  };
-  return {
-    chain: ChainName,
-    chainInfo,
-    prefix: "fastset",
-    builder: () => fallback.builder(),
-    executor: new WarpFastsetExecutor(config, chainInfo),
-    results: new WarpFastsetResults(config),
-    serializer: new WarpFastsetSerializer(),
-    registry: fallback.registry,
-    explorer: new WarpFastsetExplorer(chainInfo),
-    abiBuilder: () => fallback.abiBuilder(),
-    brandBuilder: () => fallback.brandBuilder(),
-    dataLoader: new WarpFastsetDataLoader(config, chainInfo)
-  };
-};
+    defaultApiUrl: "https://rpc.fastset.xyz",
+    nativeToken: NativeTokenSet
+  },
+  testnet: {
+    name: WarpChainName.Fastset,
+    displayName: "FastSet Testnet",
+    chainId: "testnet",
+    blockTime: 1e3,
+    addressHrp: "set",
+    defaultApiUrl: "https://rpc.fastset.xyz",
+    nativeToken: NativeTokenSet
+  },
+  devnet: {
+    name: WarpChainName.Fastset,
+    displayName: "FastSet Devnet",
+    chainId: "devnet",
+    blockTime: 1e3,
+    addressHrp: "set",
+    defaultApiUrl: "https://rpc.fastset.xyz",
+    nativeToken: NativeTokenSet
+  }
+});
 export {
   Address,
   Amount,
+  BcsTransaction,
   Bytes32,
+  Claim,
   ClaimType,
   FastsetClient,
+  NativeTokenSet,
   Nonce,
   PublicKey,
   Transaction,
   Transfer,
+  TransferClaim,
   UserData,
+  Wallet,
   WarpFastsetConstants,
+  WarpFastsetDataLoader,
   WarpFastsetExecutor,
   WarpFastsetExplorer,
   WarpFastsetResults,
   WarpFastsetSerializer,
-  decimalToHex,
-  fromBase64,
-  getFastsetAdapter,
-  hexToDecimal2 as hexToDecimal,
-  isValidFastsetAddress,
-  normalizeAmount,
-  toBase64String,
-  toHexString,
-  validateAmount,
-  validatePrivateKey,
-  validatePublicKey
+  getFastsetAdapter
 };
 //# sourceMappingURL=index.mjs.map