@vleap/warps-adapter-fastset 0.1.0-alpha.2 → 0.1.0-alpha.21

package/dist/index.mjs

@@ -1,229 +1,394 @@
-// src/constants.ts
-var WarpFastsetConstants = {
-  ChainName: "fastset",
-  ChainPrefix: "fastset",
-  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
-  },
-  Network: {
-    Mainnet: {
-      ChainId: "1",
-      Name: "Fastset Mainnet",
-      BlockTime: 12
-    },
-    Testnet: {
-      ChainId: "11155111",
-      Name: "Fastset Testnet",
-      BlockTime: 12
-    },
-    Devnet: {
-      ChainId: "1337",
-      Name: "Fastset Devnet",
-      BlockTime: 12
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/sdk/ed25519-setup.ts
+import * as ed from "@noble/ed25519";
+import { sha512 } from "@noble/hashes/sha512";
+var init_ed25519_setup = __esm({
+  "src/sdk/ed25519-setup.ts"() {
+    "use strict";
+    if (ed.etc) {
+      ed.etc.sha512Sync = (...m) => sha512(ed.etc.concatBytes(...m));
     }
-  },
-  Validation: {
-    AddressLength: 42,
-    HexPrefix: "0x",
-    MinGasLimit: 21e3,
-    MaxGasLimit: 3e7
-  },
-  Timeouts: {
-    DefaultRpcTimeout: 3e4,
-    // 30 seconds
-    GasEstimationTimeout: 1e4,
-    // 10 seconds
-    QueryTimeout: 15e3
-    // 15 seconds
   }
+});
+
+// src/sdk/FastsetClient.ts
+import * as bech32 from "bech32";
+var Transaction, FastsetClient, Wallet;
+var init_FastsetClient = __esm({
+  "src/sdk/FastsetClient.ts"() {
+    "use strict";
+    init_ed25519_setup();
+    BigInt.prototype.toJSON = function() {
+      return Number(this);
+    };
+    Transaction = class {
+      constructor(sender, recipient, nonce, claim, timestamp = BigInt(Date.now()) * 1000000n) {
+        this.sender = sender;
+        this.recipient = recipient;
+        this.nonce = nonce;
+        this.claim = claim;
+        this.timestamp = timestamp;
+        if (claim?.Transfer?.amount?.startsWith("0x")) {
+          claim = { ...claim, Transfer: { ...claim.Transfer, amount: claim.Transfer.amount.slice(2) } };
+        }
+      }
+      toTransaction() {
+        return { sender: this.sender, recipient: this.recipient, nonce: this.nonce, timestamp_nanos: this.timestamp, claim: this.claim };
+      }
+      getRecipientAddress() {
+        return this.recipient;
+      }
+      getAmount() {
+        return this.claim?.Transfer?.amount || "";
+      }
+      getUserData() {
+        return this.claim?.Transfer?.user_data || null;
+      }
+    };
+    FastsetClient = class {
+      constructor(config, chain) {
+        this.proxyUrl = config && "proxyUrl" in config ? config.proxyUrl : config && chain ? chain.defaultApiUrl : "https://proxy.fastset.xyz";
+      }
+      async makeRequest(method, params = {}) {
+        const response = await fetch(this.proxyUrl, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ jsonrpc: "2.0", method, params, id: Date.now() }, (k, v) => v instanceof Uint8Array ? Array.from(v) : v)
+        });
+        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) {
+        return this.makeRequest("set_proxy_getAccountInfo", { address });
+      }
+      async getNextNonce(address) {
+        const addressBytes = typeof address === "string" ? this.addressToBytes(address) : address;
+        const accountInfo = await this.getAccountInfo(addressBytes);
+        return accountInfo.next_nonce;
+      }
+      async submitTransaction(transaction, signature) {
+        const signatureArray = Array.isArray(signature) ? signature : Array.from(signature);
+        const submitTxReq = {
+          transaction: {
+            sender: transaction.sender instanceof Uint8Array ? transaction.sender : new Uint8Array(transaction.sender),
+            recipient: transaction.recipient,
+            nonce: transaction.nonce,
+            timestamp_nanos: transaction.timestamp_nanos,
+            claim: transaction.claim
+          },
+          signature: new Uint8Array(signatureArray)
+        };
+        const response = await fetch(this.proxyUrl, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(
+            { jsonrpc: "2.0", method: "set_proxy_submitTransaction", params: submitTxReq, id: 1 },
+            (k, v) => v instanceof Uint8Array ? Array.from(v) : v
+          )
+        });
+        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 faucetDrip(recipient, amount) {
+        const recipientArray = Array.isArray(recipient) ? recipient : Array.from(recipient);
+        return this.makeRequest("set_proxy_faucetDrip", { recipient: recipientArray, amount });
+      }
+      addressToBytes(address) {
+        try {
+          const decoded = bech32.bech32m.decode(address);
+          return Array.from(bech32.bech32m.fromWords(decoded.words));
+        } catch {
+          const decoded = bech32.bech32.decode(address);
+          return Array.from(bech32.bech32.fromWords(decoded.words));
+        }
+      }
+      // Wallet utilities
+      generateNewWallet() {
+        const privateKey = ed.utils.randomPrivateKey();
+        return new Wallet(Buffer.from(privateKey).toString("hex"));
+      }
+      createWallet(privateKeyHex) {
+        return new Wallet(privateKeyHex);
+      }
+      static decodeBech32Address(address) {
+        try {
+          const decoded = bech32.bech32m.decode(address);
+          return new Uint8Array(bech32.bech32m.fromWords(decoded.words));
+        } catch {
+          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);
+      }
+    };
+    Wallet = class {
+      constructor(privateKeyHex) {
+        this.privateKey = new Uint8Array(Buffer.from(privateKeyHex.replace(/^0x/, ""), "hex"));
+        this.publicKey = ed.getPublicKey(this.privateKey);
+      }
+      toBech32() {
+        return bech32.bech32m.encode("set", bech32.bech32m.toWords(this.publicKey));
+      }
+      signTransactionRaw(data) {
+        return ed.sign(data, this.privateKey);
+      }
+      getPrivateKey() {
+        return this.privateKey;
+      }
+    };
+  }
+});
+
+// src/sdk/index.ts
+var sdk_exports = {};
+__export(sdk_exports, {
+  FastsetClient: () => FastsetClient,
+  Transaction: () => Transaction,
+  Wallet: () => Wallet
+});
+var init_sdk = __esm({
+  "src/sdk/index.ts"() {
+    "use strict";
+    init_FastsetClient();
+  }
+});
+
+// src/main.ts
+import { WarpChainName } from "@vleap/warps";
+
+// src/WarpFastsetDataLoader.ts
+import * as bech323 from "bech32";
+
+// src/helpers/general.ts
+init_sdk();
+import { getProviderUrl } from "@vleap/warps";
+var getConfiguredFastsetClient = (config, chain) => {
+  const proxyUrl = getProviderUrl(config, chain.name, config.env, chain.defaultApiUrl);
+  return new FastsetClient({ proxyUrl });
 };
 
-// src/WarpFastsetBuilder.ts
-var WarpFastsetBuilder = class {
-  constructor(config) {
+// src/WarpFastsetDataLoader.ts
+var WarpFastsetDataLoader = class {
+  constructor(config, chain) {
     this.config = config;
-    this.warp = {};
-    this.actions = [];
+    this.chain = chain;
+    this.client = getConfiguredFastsetClient(config, chain);
+  }
+  async getAccount(address) {
+    const addressBytes = this.addressToBytes(address);
+    const accountInfo = await this.client.getAccountInfo(addressBytes);
+    return { chain: this.chain.name, address, balance: BigInt(parseInt(accountInfo.balance, 16)) };
+  }
+  async getAccountAssets(address) {
+    const addressBytes = this.addressToBytes(address);
+    const accountInfo = await this.client.getAccountInfo(addressBytes);
+    const assets = [];
+    const balance = BigInt(parseInt(accountInfo.balance, 16));
+    if (balance > 0n) {
+      assets.push({ ...this.chain.nativeToken, amount: balance });
+    }
+    for (const [tokenId, tokenBalance] of accountInfo.token_balance) {
+      const amount = BigInt(parseInt(tokenBalance, 16));
+      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 createFromRaw(encoded) {
-    try {
-      const parsed = JSON.parse(encoded);
-      this.warp = parsed;
-      this.actions = parsed.actions || [];
-      return this.build();
-    } catch (error) {
-      throw new Error(`Failed to parse Fastset warp data: ${error}`);
+  async getAsset(identifier) {
+    if (identifier === this.chain.nativeToken.identifier) {
+      return this.chain.nativeToken;
     }
+    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)
+    };
   }
-  setTitle(title) {
-    this.warp.title = title;
-    return this;
+  async getAction(identifier, awaitCompleted = false) {
+    return null;
   }
-  setDescription(description) {
-    this.warp.description = description;
-    return this;
+  async getAccountActions(address, options) {
+    return [];
   }
-  setPreview(preview) {
-    this.warp.preview = preview;
-    return this;
+  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}`);
+      }
+    }
   }
-  setActions(actions) {
-    this.actions = actions;
-    return this;
+};
+
+// src/WarpFastsetExecutor.ts
+init_sdk();
+import {
+  getWarpActionByIndex,
+  getWarpWalletAddressFromConfig
+} from "@vleap/warps";
+var WarpFastsetExecutor = class {
+  constructor(config, chain) {
+    this.config = config;
+    this.chain = chain;
+    this.fastsetClient = new FastsetClient({ proxyUrl: "https://proxy.fastset.xyz" });
   }
-  addAction(action) {
-    this.actions.push(action);
-    return this;
+  async createTransaction(executable) {
+    const action = getWarpActionByIndex(executable.warp, executable.action);
+    if (action.type === "transfer") return this.createTransferTransaction(executable);
+    if (action.type === "contract") return this.createContractCallTransaction(executable);
+    if (action.type === "query") throw new Error("WarpFastsetExecutor: Invalid type for createTransaction; Use executeQuery instead");
+    if (action.type === "collect") throw new Error("WarpFastsetExecutor: Invalid type for createTransaction; Use executeCollect instead");
+    throw new Error(`WarpFastsetExecutor: Invalid type (${action.type})`);
   }
-  async build() {
-    return {
-      protocol: "warp",
-      name: this.warp.name || "fastset-warp",
-      title: this.warp.title || "",
-      description: this.warp.description || null,
-      preview: this.warp.preview || null,
-      actions: this.actions,
-      meta: {
-        chain: "fastset",
-        hash: this.generateHash(this.warp.title || ""),
-        creator: this.config.user?.wallets?.fastset || "",
-        createdAt: (/* @__PURE__ */ new Date()).toISOString()
-      }
-    };
+  async createTransferTransaction(executable) {
+    const userWallet = getWarpWalletAddressFromConfig(this.config, executable.chain.name);
+    if (!userWallet) throw new Error("WarpFastsetExecutor: User address not set");
+    const senderAddress = FastsetClient.decodeBech32Address(userWallet);
+    const recipientAddress = FastsetClient.decodeBech32Address(executable.destination);
+    const nonce = await this.fastsetClient.getNextNonce(userWallet);
+    const amount = executable.transfers?.[0]?.amount ? "0x" + executable.transfers[0].amount.toString(16) : executable.value.toString();
+    const userData = executable.data ? this.fromBase64(executable.data) : null;
+    const claim = { Transfer: { amount, user_data: userData } };
+    return new Transaction(senderAddress, { FastSet: recipientAddress }, nonce, claim);
   }
-  createInscriptionTransaction(warp) {
+  async createContractCallTransaction(executable) {
+    const userWallet = this.config.user?.wallets?.[executable.chain.name];
+    if (!userWallet) throw new Error("WarpFastsetExecutor: User address not set");
+    const action = getWarpActionByIndex(executable.warp, executable.action);
+    if (!action || !("func" in action) || !action.func) throw new Error("Contract action must have function name");
     return {
-      type: "fastset-inscription",
-      data: JSON.stringify(warp)
-      // TODO: Add Fastset-specific transaction fields
+      type: "fastset-contract-call",
+      contract: this.fromBase64(executable.destination),
+      function: action.func,
+      data: JSON.stringify({ function: action.func, arguments: executable.args }),
+      value: executable.value,
+      chain: executable.chain
     };
   }
-  async createFromTransaction(tx, validate = true) {
-    try {
-      const warpData = tx.data || tx.payload || tx.content;
-      if (!warpData) {
-        throw new Error("No warp data found in transaction");
-      }
-      const parsed = typeof warpData === "string" ? JSON.parse(warpData) : warpData;
-      if (validate) {
-        this.validateWarp(parsed);
-      }
-      return parsed;
-    } catch (error) {
-      throw new Error(`Failed to create warp from Fastset transaction: ${error}`);
-    }
-  }
-  async createFromTransactionHash(hash, cache) {
+  async executeQuery(executable) {
+    const action = getWarpActionByIndex(executable.warp, executable.action);
+    if (action.type !== "query") throw new Error(`Invalid action type for executeQuery: ${action.type}`);
     try {
-      const tx = await this.fetchTransaction(hash);
-      if (!tx) {
-        return null;
-      }
-      return this.createFromTransaction(tx);
+      const result = await this.executeFastsetQuery(this.fromBase64(executable.destination), action.func, executable.args);
+      return { success: true, result, chain: executable.chain };
     } catch (error) {
-      console.error(`Failed to create warp from Fastset transaction hash: ${error}`);
-      return null;
-    }
+      return { success: false, error: error instanceof Error ? error.message : String(error), chain: executable.chain };
+    }
+  }
+  async executeTransfer(executable) {
+    const transaction = await this.createTransferTransaction(executable);
+    return { success: true, transaction, chain: executable.chain.name };
+  }
+  async executeTransferWithKey(executable, privateKey) {
+    const transaction = await this.createTransferTransaction(executable);
+    const privateKeyBytes = this.fromBase64(privateKey);
+    const transactionData = {
+      sender: privateKeyBytes.slice(0, 32),
+      recipient: transaction.getRecipientAddress(),
+      nonce: await this.fastsetClient.getNextNonce(FastsetClient.encodeBech32Address(privateKeyBytes.slice(0, 32))),
+      timestamp_nanos: BigInt(Date.now()) * 1000000n,
+      claim: { Transfer: { amount: transaction.getAmount(), user_data: transaction.getUserData() } }
+    };
+    const signature = await this.signTransaction(transactionData, privateKeyBytes);
+    const result = await this.fastsetClient.submitTransaction(transactionData, signature);
+    return { success: true, result, message: "Transaction submitted successfully", chain: executable.chain.name };
   }
-  generateHash(data) {
-    let hash = 0;
-    for (let i = 0; i < data.length; i++) {
-      const char = data.charCodeAt(i);
-      hash = (hash << 5) - hash + char;
-      hash = hash & hash;
-    }
-    return hash.toString(16);
+  async signTransaction(transaction, privateKey) {
+    const wallet = new (await Promise.resolve().then(() => (init_sdk(), sdk_exports))).Wallet(Buffer.from(privateKey).toString("hex"));
+    return wallet.signTransactionRaw(this.serializeTransaction(transaction));
   }
-  validateWarp(warp) {
-    if (!warp.title) {
-      throw new Error("Warp must have a title");
-    }
-    if (!warp.actions || !Array.isArray(warp.actions)) {
-      throw new Error("Warp must have actions array");
-    }
+  serializeTransaction(tx) {
+    const serialized = JSON.stringify(tx, (k, v) => v instanceof Uint8Array ? Array.from(v) : v);
+    return new TextEncoder().encode(serialized);
   }
-  async fetchTransaction(hash) {
-    const response = await fetch(`${this.getApiUrl()}/transaction/${hash}`);
-    if (!response.ok) {
-      return null;
-    }
+  async executeFastsetQuery(contractAddress, functionName, args) {
+    const response = await fetch("https://proxy.fastset.xyz", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        method: "set_proxy_query",
+        params: { contract: Array.from(contractAddress), function: functionName, arguments: args },
+        id: 1
+      })
+    });
+    if (!response.ok) throw new Error(`Query failed: ${response.statusText}`);
     return response.json();
   }
-  getApiUrl() {
-    return "https://api.fastset.xyz";
+  fromBase64(base64) {
+    return Uint8Array.from(atob(base64), (c) => c.charCodeAt(0));
   }
 };
 
-// src/WarpFastsetExecutor.ts
-import {
-  getWarpActionByIndex
-} from "@vleap/warps";
-
-// src/config.ts
-var FASTSET_CHAIN_CONFIGS = {
-  fastset: {
-    mainnet: {
-      apiUrl: "https://mainnet.fastset.com/api",
-      explorerUrl: "https://explorer.fastset.com",
-      chainId: "1",
-      registryAddress: "0x0000000000000000000000000000000000000000",
-      nativeToken: "PI",
-      blockTime: 12
-    },
-    testnet: {
-      apiUrl: "https://testnet.fastset.com/api",
-      explorerUrl: "https://testnet-explorer.fastset.com",
-      chainId: "11155111",
-      registryAddress: "0x0000000000000000000000000000000000000000",
-      nativeToken: "PI",
-      blockTime: 12
-    },
-    devnet: {
-      apiUrl: "http://localhost:8545",
-      explorerUrl: "http://localhost:4000",
-      chainId: "1337",
-      registryAddress: "0x0000000000000000000000000000000000000000",
-      nativeToken: "PI",
-      blockTime: 12
-    }
+// src/WarpFastsetExplorer.ts
+var WarpFastsetExplorer = class {
+  constructor(_chainInfo, _config) {
+    this._chainInfo = _chainInfo;
+    this._config = _config;
+    this.explorerUrl = "https://explorer.fastset.xyz";
   }
-};
-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}`);
+  getAccountUrl(address) {
+    return `${this.explorerUrl}/account/${address}`;
   }
-  const config = chainConfigs[env];
-  if (!config) {
-    throw new Error(`Unsupported environment ${env} for chain ${chain}`);
+  getTransactionUrl(hash) {
+    return `${this.explorerUrl}/transaction/${hash}`;
+  }
+  getAssetUrl(identifier) {
+    return `${this.explorerUrl}/asset/${identifier}`;
+  }
+  getContractUrl(address) {
+    return `${this.explorerUrl}/account/${address}`;
   }
-  return config;
-};
-var getFastsetApiUrl = (env, chain = DEFAULT_CHAIN) => {
-  return getFastsetChainConfig(chain, env).apiUrl;
 };
 
+// src/WarpFastsetResults.ts
+import {
+  evaluateResultsCommon,
+  getWarpWalletAddressFromConfig as getWarpWalletAddressFromConfig2,
+  parseResultsOutIndex,
+  WarpConstants
+} from "@vleap/warps";
+
 // src/WarpFastsetSerializer.ts
 import {
   WarpSerializer
@@ -243,7 +408,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(",");
@@ -268,7 +433,7 @@ var WarpFastsetSerializer = class {
       return ["boolean", value];
     }
     if (typeof value === "bigint") {
-      return ["bigint", value];
+      return ["biguint", value.toString()];
     }
     return ["string", String(value)];
   }
@@ -280,8 +445,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);
     }
@@ -294,8 +463,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";
     }
@@ -314,7 +487,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));
@@ -328,211 +501,28 @@ var WarpFastsetSerializer = class {
   }
 };
 
-// src/WarpFastsetExecutor.ts
-var WarpFastsetExecutor = class {
-  constructor(config) {
-    this.config = config;
-    this.serializer = new WarpFastsetSerializer();
-  }
-  async createTransaction(executable) {
-    const action = getWarpActionByIndex(executable.warp, executable.action);
-    let tx = null;
-    if (action.type === "transfer") {
-      tx = await this.createTransferTransaction(executable);
-    } else if (action.type === "contract") {
-      tx = await this.createContractCallTransaction(executable);
-    } else if (action.type === "query") {
-      throw new Error("WarpFastsetExecutor: Invalid action type for createTransaction; Use executeQuery instead");
-    } else if (action.type === "collect") {
-      throw new Error("WarpFastsetExecutor: Invalid action type for createTransaction; Use executeCollect instead");
-    }
-    if (!tx) throw new Error(`WarpFastsetExecutor: Invalid action type (${action.type})`);
-    return tx;
-  }
-  async createTransferTransaction(executable) {
-    const userWallet = this.config.user?.wallets?.[executable.chain.name];
-    if (!userWallet) throw new Error("WarpFastsetExecutor: createTransfer - user address not set");
-    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}`);
-    }
-    return {
-      type: "fastset-transfer",
-      from: userWallet,
-      to: executable.destination,
-      value: executable.value,
-      data: executable.data ? this.serializer.stringToTyped(executable.data) : ""
-      // TODO: Add Fastset-specific transaction fields
-    };
-  }
-  async createContractCallTransaction(executable) {
-    const userWallet = this.config.user?.wallets?.[executable.chain.name];
-    if (!userWallet) throw new Error("WarpFastsetExecutor: createContractCall - user address not set");
-    const action = getWarpActionByIndex(executable.warp, executable.action);
-    if (!action || !("func" in action) || !action.func) {
-      throw new Error("WarpFastsetExecutor: Contract action must have a function name");
-    }
-    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 encodedData = this.encodeFunctionData(action.func, executable.args);
-      return {
-        type: "fastset-contract-call",
-        from: userWallet,
-        to: executable.destination,
-        value: executable.value,
-        data: encodedData,
-        function: action.func
-        // TODO: Add Fastset-specific transaction fields
-      };
-    } catch (error) {
-      throw new Error(`WarpFastsetExecutor: Failed to encode function data for ${action.func}: ${error}`);
-    }
-  }
-  async executeQuery(executable) {
-    const action = getWarpActionByIndex(executable.warp, executable.action);
-    if (action.type !== "query") {
-      throw new Error(`WarpFastsetExecutor: Invalid action type for executeQuery: ${action.type}`);
-    }
-    if (!action.func) {
-      throw new Error("WarpFastsetExecutor: Query action must have a function name");
-    }
-    if (!this.isValidFastsetAddress(executable.destination)) {
-      throw new Error(`WarpFastsetExecutor: Invalid contract address for query: ${executable.destination}`);
-    }
-    try {
-      const result = await this.executeFastsetQuery(executable.destination, action.func, executable.args);
-      return {
-        success: true,
-        result
-        // TODO: Add Fastset-specific result fields
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : String(error)
-        // TODO: Add Fastset-specific error fields
-      };
-    }
-  }
-  async preprocessInput(chain, input, type, value) {
-    const typedValue = this.serializer.stringToTyped(value);
-    switch (type) {
-      case "address":
-        if (!this.isValidFastsetAddress(typedValue)) {
-          throw new Error(`Invalid Fastset address format: ${typedValue}`);
-        }
-        return typedValue;
-      case "number":
-        const numValue = Number(typedValue);
-        if (isNaN(numValue)) {
-          throw new Error(`Invalid number format: ${typedValue}`);
-        }
-        return numValue.toString();
-      case "bigint":
-        const bigIntValue = BigInt(typedValue);
-        if (bigIntValue < 0) {
-          throw new Error(`Negative value not allowed for type ${type}: ${typedValue}`);
-        }
-        return bigIntValue.toString();
-      default:
-        return String(typedValue);
-    }
-  }
-  isValidFastsetAddress(address) {
-    return typeof address === "string" && address.length > 0;
-  }
-  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: contractAddress,
-        function: functionName,
-        arguments: args
-      })
-    });
-    if (!response.ok) {
-      throw new Error(`Fastset query failed: ${response.statusText}`);
-    }
-    return response.json();
-  }
-  async signMessage(message, privateKey) {
-    throw new Error("Not implemented");
-  }
-};
-
-// src/WarpFastsetExplorer.ts
-var WarpFastsetExplorer = class {
-  constructor(chainInfo, chainName = "fastset") {
-    this.chainInfo = chainInfo;
-    this.chainName = chainName;
-  }
-  getAccountUrl(address) {
-    const baseUrl = this.chainInfo.explorerUrl || this.getDefaultExplorerUrl();
-    return `${baseUrl}/address/${address}`;
-  }
-  getTransactionUrl(hash) {
-    const baseUrl = this.chainInfo.explorerUrl || this.getDefaultExplorerUrl();
-    return `${baseUrl}/tx/${hash}`;
-  }
-  getBlockUrl(blockNumber) {
-    const baseUrl = this.chainInfo.explorerUrl || this.getDefaultExplorerUrl();
-    return `${baseUrl}/block/${blockNumber}`;
-  }
-  getContractUrl(address) {
-    const baseUrl = this.chainInfo.explorerUrl || this.getDefaultExplorerUrl();
-    return `${baseUrl}/contract/${address}`;
-  }
-  getTokenUrl(address) {
-    const baseUrl = this.chainInfo.explorerUrl || this.getDefaultExplorerUrl();
-    return `${baseUrl}/token/${address}`;
-  }
-  getDefaultExplorerUrl() {
-    return `https://explorer.fastset.xyz`;
-  }
-};
-
 // src/WarpFastsetResults.ts
-import {
-  evaluateResultsCommon,
-  parseResultsOutIndex,
-  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: getWarpWalletAddressFromConfig2(this.config, this.chain.name),
       txHash: transactionHash,
+      tx,
       next: null,
-      values: [transactionHash, blockNumber, gasUsed, gasPrice, ...logs.length > 0 ? logs : []],
+      values: [transactionHash, blockNumber, timestamp],
+      valuesRaw: [transactionHash, blockNumber, timestamp],
       results: {},
       messages: {}
     };
@@ -543,6 +533,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]];
@@ -560,64 +555,171 @@ 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;
       }
     }
-    return { values, results: await evaluateResultsCommon(warp, results, actionIndex, inputs) };
+    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/WarpFastsetWallet.ts
+init_sdk();
+init_ed25519_setup();
+import {
+  getWarpWalletAddressFromConfig as getWarpWalletAddressFromConfig3
+} from "@vleap/warps";
+var WarpFastsetWallet = class {
+  constructor(config, chain) {
+    this.config = config;
+    this.chain = chain;
+    this.wallet = null;
+    this.initializeWallet();
+  }
+  initializeWallet() {
+    const walletConfig = this.config.user?.wallets?.[this.chain.name];
+    if (walletConfig && typeof walletConfig === "object" && "privateKey" in walletConfig && walletConfig.privateKey) {
+      this.wallet = new Wallet(walletConfig.privateKey);
+    }
+  }
+  async signTransaction(tx) {
+    if (!this.wallet) throw new Error("Wallet not initialized");
+    const transaction = tx;
+    const serializedTx = this.serializeTransaction(transaction.toTransaction());
+    const signature = await ed.sign(serializedTx, this.wallet.getPrivateKey());
+    return Object.assign(transaction, { signature });
+  }
+  async signMessage(message) {
+    if (!this.wallet) throw new Error("Wallet not initialized");
+    const signature = await ed.sign(new TextEncoder().encode(message), this.wallet.getPrivateKey());
+    return Buffer.from(signature).toString("hex");
+  }
+  async sendTransaction(tx) {
+    if (!this.wallet) throw new Error("Wallet not initialized");
+    const transaction = tx;
+    const fastsetTx = transaction.toTransaction();
+    const transactionData = {
+      sender: fastsetTx.sender,
+      recipient: fastsetTx.recipient,
+      nonce: fastsetTx.nonce,
+      timestamp_nanos: fastsetTx.timestamp_nanos,
+      claim: fastsetTx.claim
+    };
+    const signature = tx.signature ? new Uint8Array(Buffer.from(tx.signature, "hex")) : await ed.sign(this.serializeTransaction(transactionData), this.wallet.getPrivateKey());
+    const client = new FastsetClient({ proxyUrl: "https://proxy.fastset.xyz" });
+    return await client.submitTransaction(transactionData, signature);
+  }
+  create(mnemonic) {
+    const wallet = new Wallet(mnemonic);
+    return { address: wallet.toBech32(), privateKey: Buffer.from(wallet.getPrivateKey()).toString("hex"), mnemonic };
+  }
+  generate() {
+    const privateKey = ed.utils.randomPrivateKey();
+    const wallet = new Wallet(Buffer.from(privateKey).toString("hex"));
+    return { address: wallet.toBech32(), privateKey: Buffer.from(privateKey).toString("hex"), mnemonic: null };
+  }
+  getAddress() {
+    return getWarpWalletAddressFromConfig3(this.config, this.chain.name);
+  }
+  serializeTransaction(tx) {
+    const serialized = JSON.stringify(tx, (k, v) => v instanceof Uint8Array ? Array.from(v) : v);
+    return new TextEncoder().encode(serialized);
   }
 };
 
 // src/main.ts
-var getFastsetAdapter = (config, fallback) => {
-  if (!fallback) throw new Error("Fastset adapter requires a fallback adapter");
-  return {
-    chain: WarpFastsetConstants.ChainName,
-    prefix: WarpFastsetConstants.ChainPrefix,
-    builder: () => new WarpFastsetBuilder(config),
-    executor: new WarpFastsetExecutor(config),
-    results: new WarpFastsetResults(config),
-    serializer: new WarpFastsetSerializer(),
-    registry: fallback.registry,
-    explorer: (chainInfo) => new WarpFastsetExplorer(chainInfo),
-    abiBuilder: () => fallback.abiBuilder(),
-    brandBuilder: () => fallback.brandBuilder()
-  };
+var NativeTokenSet = {
+  chain: WarpChainName.Fastset,
+  identifier: "SET",
+  name: "SET",
+  symbol: "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),
+      wallet: new WarpFastsetWallet(config, chainInfo)
+    };
+  };
+}
+var getFastsetAdapter = createFastsetAdapter(WarpChainName.Fastset, "fastset", {
+  mainnet: {
+    name: WarpChainName.Fastset,
+    displayName: "FastSet",
+    chainId: "1",
+    blockTime: 1e3,
+    addressHrp: "set",
+    defaultApiUrl: "https://proxy.fastset.xyz",
+    nativeToken: NativeTokenSet
+  },
+  testnet: {
+    name: WarpChainName.Fastset,
+    displayName: "FastSet Testnet",
+    chainId: "testnet",
+    blockTime: 1e3,
+    addressHrp: "set",
+    defaultApiUrl: "https://proxy.fastset.xyz",
+    nativeToken: NativeTokenSet
+  },
+  devnet: {
+    name: WarpChainName.Fastset,
+    displayName: "FastSet Devnet",
+    chainId: "devnet",
+    blockTime: 1e3,
+    addressHrp: "set",
+    defaultApiUrl: "https://proxy.fastset.xyz",
+    nativeToken: NativeTokenSet
+  }
+});
+
+// src/index.ts
+init_sdk();
 export {
-  WarpFastsetBuilder,
-  WarpFastsetConstants,
+  FastsetClient,
+  NativeTokenSet,
+  Transaction,
+  Wallet,
   WarpFastsetExecutor,
-  WarpFastsetExplorer,
-  WarpFastsetResults,
-  WarpFastsetSerializer,
+  WarpFastsetWallet,
   getFastsetAdapter
 };
 //# sourceMappingURL=index.mjs.map