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

package/dist/index.mjs

@@ -1,227 +1,355 @@
 // 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
-    }
-  },
-  Validation: {
-    AddressLength: 42,
-    HexPrefix: "0x",
-    MinGasLimit: 21e3,
-    MaxGasLimit: 3e7
-  },
-  Timeouts: {
-    DefaultRpcTimeout: 3e4,
-    // 30 seconds
-    GasEstimationTimeout: 1e4,
-    // 10 seconds
-    QueryTimeout: 15e3
-    // 15 seconds
-  }
+  // Placeholder for future FastSet-specific constants
 };
 
-// src/WarpFastsetBuilder.ts
-var WarpFastsetBuilder = class {
-  constructor(config) {
-    this.config = config;
-    this.warp = {};
-    this.actions = [];
-  }
-  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}`);
+// src/main.ts
+import { WarpChainName } from "@vleap/warps";
+
+// src/WarpFastsetDataLoader.ts
+import * as bech323 from "bech32";
+
+// src/sdk/FastsetClient.ts
+import { bcs } from "@mysten/bcs";
+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: 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())]))
+    })
+  })
+});
+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";
+    }
+  }
+  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;
   }
-  setTitle(title) {
-    this.warp.title = title;
-    return this;
+  async getAccountInfo(address, token_balance_filter, certificate_by_nonce) {
+    return this.makeRequest("set_getAccountInfo", {
+      address,
+      token_balance_filter,
+      certificate_by_nonce
+    });
   }
-  setDescription(description) {
-    this.warp.description = description;
-    return this;
+  async getTokenInfo(token_ids) {
+    return this.makeRequest("set_getTokenInfo", {
+      token_ids
+    });
   }
-  setPreview(preview) {
-    this.warp.preview = preview;
-    return this;
+  async getTransfers(page) {
+    return this.makeRequest("set_getTransfers", { page });
   }
-  setActions(actions) {
-    this.actions = actions;
-    return this;
+  async getClaims(confirmed, page) {
+    return this.makeRequest("set_getClaims", { confirmed, page });
   }
-  addAction(action) {
-    this.actions.push(action);
-    return this;
+  async getClaimsByAddress(address, page) {
+    return this.makeRequest("set_getClaimsByAddress", {
+      address,
+      page
+    });
   }
-  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 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;
   }
-  createInscriptionTransaction(warp) {
-    return {
-      type: "fastset-inscription",
-      data: JSON.stringify(warp)
-      // TODO: Add Fastset-specific transaction fields
-    };
+  async submitTransaction(transaction, signature) {
+    const signatureArray = Array.isArray(signature) ? signature : Array.from(signature);
+    return this.makeRequest("set_submitTransaction", {
+      transaction,
+      signature: signatureArray
+    });
   }
-  async createFromTransaction(tx, validate = true) {
+  addressToBytes(address) {
     try {
-      const warpData = tx.data || tx.payload || tx.content;
-      if (!warpData) {
-        throw new Error("No warp data found in transaction");
+      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}`);
       }
-      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) {
+};
+
+// src/WarpFastsetDataLoader.ts
+var WarpFastsetDataLoader = class {
+  constructor(config, chain) {
+    this.config = config;
+    this.chain = chain;
+    this.client = new FastsetClient(config, chain);
+  }
+  addressToBytes(address) {
     try {
-      const tx = await this.fetchTransaction(hash);
-      if (!tx) {
-        return null;
+      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}`);
       }
-      return this.createFromTransaction(tx);
-    } catch (error) {
-      console.error(`Failed to create warp from Fastset transaction hash: ${error}`);
-      return null;
-    }
-  }
-  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);
   }
-  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");
+  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) };
+  }
+  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 fetchTransaction(hash) {
-    const response = await fetch(`${this.getApiUrl()}/transaction/${hash}`);
-    if (!response.ok) {
+  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 response.json();
+    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)
+    };
   }
-  getApiUrl() {
-    return "https://api.fastset.xyz";
+  async getAction(identifier, awaitCompleted = false) {
+    return null;
+  }
+  async getAccountActions(address, options) {
+    return [];
   }
 };
 
 // src/WarpFastsetExecutor.ts
+import * as ed25519 from "@noble/ed25519";
 import {
+  getProviderUrl,
   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/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";
+if (ed.etc) {
+  ed.etc.sha512Sync = (...m) => sha512(ed.etc.concatBytes(...m));
+}
+
+// src/sdk/Transaction.ts
+var Transaction = class _Transaction {
+  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;
+  }
+  toTransaction() {
+    return {
+      sender: this.sender,
+      recipient: this.recipient,
+      nonce: this.nonce,
+      timestamp_nanos: this.timestamp,
+      claim: this.claim
+    };
   }
-};
-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}`);
+  getSender() {
+    return this.sender;
   }
-  const config = chainConfigs[env];
-  if (!config) {
-    throw new Error(`Unsupported environment ${env} for chain ${chain}`);
+  getRecipient() {
+    return this.recipient;
+  }
+  getNonce() {
+    return this.nonce;
+  }
+  getClaim() {
+    return this.claim;
+  }
+  getTimestamp() {
+    return this.timestamp;
+  }
+  static fromTransaction(transaction) {
+    return new _Transaction(transaction.sender, transaction.recipient, transaction.nonce, transaction.claim, {
+      timestamp: transaction.timestamp_nanos
+    });
   }
-  return config;
 };
-var getFastsetApiUrl = (env, chain = DEFAULT_CHAIN) => {
-  return getFastsetChainConfig(chain, env).apiUrl;
+
+// 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 = bech325.bech32m.toWords(this.publicKey);
+    return bech325.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 {
+      Transfer: {
+        recipient: { FastSet: recipientBytes },
+        amount: amount.toString(),
+        user_data: userData
+      }
+    };
+  }
+  createTransaction(nonce, recipient, claim) {
+    return new Transaction(this.publicKey, recipient, nonce, claim);
+  }
+  static decodeBech32Address(address) {
+    try {
+      const decoded = bech325.bech32m.decode(address);
+      return new Uint8Array(bech325.bech32m.fromWords(decoded.words));
+    } catch (error) {
+      const decoded = bech325.bech32.decode(address);
+      return new Uint8Array(bech325.bech32.fromWords(decoded.words));
+    }
+  }
+  static encodeBech32Address(publicKey) {
+    const words = bech325.bech32m.toWords(publicKey);
+    return bech325.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/WarpFastsetSerializer.ts
@@ -243,7 +371,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 +396,7 @@ var WarpFastsetSerializer = class {
       return ["boolean", value];
     }
     if (typeof value === "bigint") {
-      return ["bigint", value];
+      return ["biguint", value.toString()];
     }
     return ["string", String(value)];
   }
@@ -280,8 +408,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 +426,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 +450,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));
@@ -330,24 +466,29 @@ var WarpFastsetSerializer = class {
 
 // src/WarpFastsetExecutor.ts
 var WarpFastsetExecutor = class {
-  constructor(config) {
+  constructor(config, chain) {
     this.config = config;
+    this.chain = chain;
     this.serializer = new WarpFastsetSerializer();
+    const proxyUrl = getProviderUrl(this.config, chain.name, this.config.env, this.chain.defaultApiUrl);
+    this.fastsetClient = new FastsetClient({
+      proxyUrl
+    });
   }
   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;
+    switch (action.type) {
+      case "transfer":
+        return this.createTransferTransaction(executable);
+      case "contract":
+        return this.createContractCallTransaction(executable);
+      case "query":
+        throw new Error("WarpFastsetExecutor: Invalid action type for createTransaction; Use executeQuery instead");
+      case "collect":
+        throw new Error("WarpFastsetExecutor: Invalid action type for createTransaction; Use executeCollect instead");
+      default:
+        throw new Error(`WarpFastsetExecutor: Invalid action type (${action.type})`);
+    }
   }
   async createTransferTransaction(executable) {
     const userWallet = this.config.user?.wallets?.[executable.chain.name];
@@ -358,13 +499,15 @@ var WarpFastsetExecutor = class {
     if (executable.value < 0) {
       throw new Error(`WarpFastsetExecutor: Transfer value cannot be negative: ${executable.value}`);
     }
+    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",
-      from: userWallet,
-      to: executable.destination,
-      value: executable.value,
-      data: executable.data ? this.serializer.stringToTyped(executable.data) : ""
-      // TODO: Add Fastset-specific transaction fields
+      recipient: recipientAddress,
+      amount,
+      userData,
+      chain: executable.chain
     };
   }
   async createContractCallTransaction(executable) {
@@ -381,15 +524,15 @@ var WarpFastsetExecutor = class {
       throw new Error(`WarpFastsetExecutor: Contract call value cannot be negative: ${executable.value}`);
     }
     try {
+      const contractAddress = this.fromBase64(executable.destination);
       const encodedData = this.encodeFunctionData(action.func, executable.args);
       return {
         type: "fastset-contract-call",
-        from: userWallet,
-        to: executable.destination,
-        value: executable.value,
+        contract: contractAddress,
+        function: action.func,
         data: encodedData,
-        function: action.func
-        // TODO: Add Fastset-specific transaction fields
+        value: executable.value,
+        chain: executable.chain
       };
     } catch (error) {
       throw new Error(`WarpFastsetExecutor: Failed to encode function data for ${action.func}: ${error}`);
@@ -407,46 +550,72 @@ var WarpFastsetExecutor = class {
       throw new Error(`WarpFastsetExecutor: Invalid contract address for query: ${executable.destination}`);
     }
     try {
-      const result = await this.executeFastsetQuery(executable.destination, action.func, executable.args);
+      const contractAddress = this.fromBase64(executable.destination);
+      const result = await this.executeFastsetQuery(contractAddress, action.func, executable.args);
       return {
         success: true,
-        result
-        // TODO: Add Fastset-specific result fields
+        result,
+        chain: executable.chain
       };
     } catch (error) {
       return {
         success: false,
-        error: error instanceof Error ? error.message : String(error)
-        // TODO: Add Fastset-specific error fields
+        error: error instanceof Error ? error.message : String(error),
+        chain: executable.chain
       };
     }
   }
-  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);
-    }
+  async signMessage(message, privateKey) {
+    throw new Error("Not implemented");
   }
-  isValidFastsetAddress(address) {
-    return typeof address === "string" && address.length > 0;
+  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");
+    const transaction = await this.createTransferTransaction(executable);
+    return {
+      success: true,
+      transaction,
+      chain: executable.chain.name,
+      message: "Transaction created successfully. Use executeTransferWithKey to execute with private key."
+    };
+  }
+  async executeTransferWithKey(executable, privateKey) {
+    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 = this.fromBase64(privateKey);
+    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),
+      chain: executable.chain.name
+    };
   }
   encodeFunctionData(functionName, args) {
     return JSON.stringify({
@@ -455,13 +624,14 @@ var WarpFastsetExecutor = class {
     });
   }
   async executeFastsetQuery(contractAddress, functionName, args) {
-    const response = await fetch(`${getFastsetApiUrl(this.config.env, "fastset")}/query`, {
+    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: contractAddress,
+        contract: Array.from(contractAddress),
         function: functionName,
         arguments: args
       })
@@ -471,39 +641,46 @@ var WarpFastsetExecutor = class {
     }
     return response.json();
   }
-  async signMessage(message, privateKey) {
-    throw new Error("Not implemented");
+  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, chainName = "fastset") {
-    this.chainInfo = chainInfo;
-    this.chainName = chainName;
+  constructor(_chainInfo, _config) {
+    this._chainInfo = _chainInfo;
+    this._config = _config;
+    this.explorerUrl = "https://explorer.fastset.xyz";
   }
   getAccountUrl(address) {
-    const baseUrl = this.chainInfo.explorerUrl || this.getDefaultExplorerUrl();
-    return `${baseUrl}/address/${address}`;
+    return `${this.explorerUrl}/account/${address}`;
   }
   getTransactionUrl(hash) {
-    const baseUrl = this.chainInfo.explorerUrl || this.getDefaultExplorerUrl();
-    return `${baseUrl}/tx/${hash}`;
+    return `${this.explorerUrl}/transaction/${hash}`;
   }
-  getBlockUrl(blockNumber) {
-    const baseUrl = this.chainInfo.explorerUrl || this.getDefaultExplorerUrl();
-    return `${baseUrl}/block/${blockNumber}`;
+  getAssetUrl(identifier) {
+    return `${this.explorerUrl}/asset/${identifier}`;
   }
   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`;
+    return `${this.explorerUrl}/account/${address}`;
   }
 };
 
@@ -514,25 +691,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: {}
     };
@@ -543,6 +721,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,60 +743,101 @@ 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/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)
+    };
+  };
+}
+var getFastsetAdapter = createFastsetAdapter(WarpChainName.Fastset, "fastset", {
+  mainnet: {
+    name: WarpChainName.Fastset,
+    displayName: "FastSet",
+    chainId: "1",
+    blockTime: 1e3,
+    addressHrp: "set",
+    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 {
-  WarpFastsetBuilder,
+  FastsetClient,
+  NativeTokenSet,
   WarpFastsetConstants,
+  WarpFastsetDataLoader,
   WarpFastsetExecutor,
   WarpFastsetExplorer,
   WarpFastsetResults,