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

package/dist/index.js

@@ -0,0 +1,1075 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Address: () => Address,
+  Amount: () => Amount,
+  BcsTransaction: () => BcsTransaction,
+  Bytes32: () => Bytes32,
+  Claim: () => Claim,
+  ClaimType: () => ClaimType,
+  FastsetClient: () => FastsetClient,
+  NativeTokenSet: () => NativeTokenSet,
+  Nonce: () => Nonce,
+  PublicKey: () => PublicKey,
+  Transaction: () => Transaction,
+  Transfer: () => Transfer,
+  TransferClaim: () => TransferClaim,
+  UserData: () => UserData,
+  Wallet: () => Wallet,
+  WarpFastsetConstants: () => WarpFastsetConstants,
+  WarpFastsetDataLoader: () => WarpFastsetDataLoader,
+  WarpFastsetExecutor: () => WarpFastsetExecutor,
+  WarpFastsetExplorer: () => WarpFastsetExplorer,
+  WarpFastsetResults: () => WarpFastsetResults,
+  WarpFastsetSerializer: () => WarpFastsetSerializer,
+  getFastsetAdapter: () => getFastsetAdapter
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/constants.ts
+var WarpFastsetConstants = {
+  // Placeholder for future FastSet-specific constants
+};
+
+// src/main.ts
+var import_warps4 = require("@vleap/warps");
+
+// src/sdk/FastsetClient.ts
+var import_ed255192 = require("@noble/ed25519");
+
+// src/sdk/TransactionSigner.ts
+var import_ed25519 = require("@noble/ed25519");
+
+// src/sdk/types.ts
+var import_bcs = require("@mysten/bcs");
+BigInt.prototype.toJSON = function() {
+  return Number(this);
+};
+var Bytes32 = import_bcs.bcs.fixedArray(32, import_bcs.bcs.u8());
+var PublicKey = Bytes32;
+var Address = import_bcs.bcs.enum("Address", {
+  External: PublicKey,
+  FastSet: PublicKey
+});
+var Amount = import_bcs.bcs.u256().transform({
+  input: (val) => hexToDecimal(val.toString()),
+  output: (value) => value
+});
+var UserData = import_bcs.bcs.option(Bytes32);
+var Nonce = import_bcs.bcs.u64();
+var Transfer = import_bcs.bcs.struct("Transfer", {
+  recipient: Address,
+  amount: Amount,
+  user_data: UserData
+});
+var ClaimType = import_bcs.bcs.enum("ClaimType", {
+  Transfer
+});
+var BcsTransaction = import_bcs.bcs.struct("Transaction", {
+  sender: PublicKey,
+  nonce: Nonce,
+  timestamp_nanos: import_bcs.bcs.u128(),
+  claim: ClaimType
+});
+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 (0, import_ed25519.sign)(dataToSign, privateKey);
+  }
+};
+
+// src/sdk/Wallet.ts
+var bech32 = __toESM(require("bech32"), 1);
+
+// 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
+var ed = __toESM(require("@noble/ed25519"), 1);
+var import_sha512 = require("@noble/hashes/sha512");
+if (ed.etc) {
+  ed.etc.sha512Sync = (...m) => (0, import_sha512.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 FASTSET_VALIDATOR_URL = "http://157.90.201.117:8765";
+var FASTSET_PROXY_URL = "http://136.243.61.168:44444";
+var FastsetClient = class {
+  constructor(config) {
+    this.config = config || {
+      validatorUrl: FASTSET_VALIDATOR_URL,
+      proxyUrl: FASTSET_PROXY_URL
+    };
+  }
+  async getAccountInfo(address) {
+    try {
+      const addressBytes = Wallet.decodeBech32Address(address);
+      const response = await this.requestValidator("set_getAccountInfo", {
+        address: Array.from(addressBytes)
+      });
+      return response.result;
+    } catch (error) {
+      return null;
+    }
+  }
+  async getNextNonce(senderAddress) {
+    const accountInfo = await this.getAccountInfo(senderAddress);
+    return accountInfo?.next_nonce ?? 0;
+  }
+  async getAssetBalance(accountId, assetId) {
+    try {
+      const response = await this.requestValidator("vsl_getAssetBalance", {
+        account_id: accountId,
+        assert_id: assetId
+      });
+      return response.result;
+    } catch (error) {
+      return null;
+    }
+  }
+  async getAssetBalances(accountId) {
+    try {
+      const response = await this.requestValidator("vsl_getAssetBalances", {
+        account_id: accountId
+      });
+      return response.result;
+    } catch (error) {
+      return null;
+    }
+  }
+  async fundFromFaucet(recipientAddress, amount) {
+    const recipientBytes = Wallet.decodeBech32Address(recipientAddress);
+    const response = await this.requestProxy("faucetDrip", {
+      recipient: Array.from(recipientBytes),
+      amount
+    });
+    return response.result;
+  }
+  async submitTransaction(request) {
+    const response = await this.requestValidator("set_submitTransaction", {
+      transaction: request.transaction,
+      signature: Array.from(request.signature)
+    });
+    const result = response.result;
+    return {
+      transaction_hash: new Uint8Array(result.transaction_hash),
+      validator: new Uint8Array(result.validator),
+      signature: new Uint8Array(result.signature)
+    };
+  }
+  async submitCertificate(request) {
+    await this.requestValidator("set_submitTransactionCertificate", {
+      transaction: request.transaction,
+      signature: Array.from(request.signature),
+      validator_signatures: request.validator_signatures.map(([validator, signature]) => [Array.from(validator), Array.from(signature)])
+    });
+  }
+  async executeTransfer(senderPrivateKey, recipient, amount, userData) {
+    const senderPublicKey = await (0, import_ed255192.getPublicKey)(senderPrivateKey);
+    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: recipientBytes },
+          amount,
+          user_data: userData ?? null
+        }
+      }
+    };
+    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 submitClaim(senderPrivateKey, claim) {
+    const senderPublicKey = await (0, import_ed255192.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) {
+    return await TransactionSigner.signTransaction(transaction, privateKey);
+  }
+  async getTransactionStatus(txHash) {
+    try {
+      const response = await this.requestValidator("set_getTransactionStatus", {
+        hash: txHash
+      });
+      return response.result;
+    } catch (error) {
+      return null;
+    }
+  }
+  async getTransactionInfo(txHash) {
+    try {
+      const response = await this.requestValidator("set_getTransactionInfo", {
+        hash: txHash
+      });
+      return response.result;
+    } catch (error) {
+      return null;
+    }
+  }
+  async getNetworkInfo() {
+    try {
+      const response = await this.requestValidator("set_getNetworkInfo", {});
+      return response.result;
+    } catch (error) {
+      return null;
+    }
+  }
+  async requestValidator(method, params) {
+    return this.request(this.config.validatorUrl, method, params);
+  }
+  async requestProxy(method, params) {
+    return this.request(this.config.proxyUrl, method, params);
+  }
+  async request(url, method, params) {
+    try {
+      const request = {
+        jsonrpc: "2.0",
+        id: 1,
+        method,
+        params
+      };
+      const response = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(request, this.jsonReplacer)
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP request failed: ${response.statusText}`);
+      }
+      const jsonResponse = await response.json();
+      if (jsonResponse.error) {
+        throw new Error(`RPC error: ${jsonResponse.error.message}`);
+      }
+      return jsonResponse;
+    } catch (error) {
+      console.error(`Fastset RPC request failed: ${error}`);
+      throw error;
+    }
+  }
+  jsonReplacer(key, value) {
+    if (value instanceof Uint8Array) {
+      return Array.from(value);
+    }
+    return value;
+  }
+};
+
+// src/WarpFastsetDataLoader.ts
+var WarpFastsetDataLoader = class {
+  constructor(config, chain) {
+    this.config = config;
+    this.chain = chain;
+    this.client = new FastsetClient();
+  }
+  async getAccount(address) {
+    const accountInfo = await this.client.getAccountInfo(address);
+    if (!accountInfo) {
+      return {
+        chain: this.chain.name,
+        address,
+        balance: BigInt(0)
+      };
+    }
+    return {
+      chain: this.chain.name,
+      address,
+      balance: BigInt(parseInt(accountInfo.balance, 16))
+    };
+  }
+  async getAccountAssets(address) {
+    const accountReq = this.getAccount(address);
+    const assetBalancesReq = this.client.getAssetBalances(address);
+    const [account, assetBalances] = await Promise.all([accountReq, assetBalancesReq]);
+    const assets = [];
+    if (account.balance > 0) {
+      assets.push({
+        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
+      });
+    }
+    if (assetBalances) {
+      for (const [assetId, assetBalance] of Object.entries(assetBalances)) {
+        if (assetBalance.balance) {
+          const amount = BigInt(assetBalance.balance);
+          if (amount > 0) {
+            assets.push({
+              chain: this.chain.name,
+              identifier: assetId,
+              name: assetBalance.name || assetId,
+              decimals: assetBalance.decimals || 6,
+              amount,
+              logoUrl: assetBalance.logo_url
+            });
+          }
+        }
+      }
+    }
+    return assets;
+  }
+  async getAccountActions(address, options) {
+    return [];
+  }
+  async getAccountInfo(address) {
+    const accountInfo = await this.client.getAccountInfo(address);
+    if (!accountInfo) {
+      return null;
+    }
+    const balanceDecimal = parseInt(accountInfo.balance, 16);
+    return {
+      address,
+      balance: accountInfo.balance,
+      balanceDecimal,
+      nextNonce: accountInfo.next_nonce,
+      sequenceNumber: accountInfo.sequence_number
+    };
+  }
+  async getTransactionInfo(txHash) {
+    return {
+      hash: txHash,
+      hashHex: txHash.startsWith("0x") ? txHash.slice(2) : txHash,
+      status: "submitted",
+      details: {
+        hash: txHash,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    };
+  }
+  async checkTransferStatus(fromAddress, toAddress, amount) {
+    const fromAccount = await this.getAccountInfo(fromAddress);
+    const toAccount = await this.getAccountInfo(toAddress);
+    if (!fromAccount || !toAccount) {
+      return false;
+    }
+    const transferAmount = parseInt(amount);
+    const fromBalance = fromAccount.balanceDecimal;
+    return fromBalance < transferAmount;
+  }
+  async getAccountBalance(address) {
+    const accountInfo = await this.getAccountInfo(address);
+    if (!accountInfo) {
+      return null;
+    }
+    return {
+      balance: accountInfo.balance,
+      balanceDecimal: accountInfo.balanceDecimal
+    };
+  }
+  async getAssetBalance(address, assetId) {
+    const assetBalance = await this.client.getAssetBalance(address, assetId);
+    if (!assetBalance || !assetBalance.balance) {
+      return null;
+    }
+    const amount = BigInt(assetBalance.balance);
+    if (amount === 0n) {
+      return null;
+    }
+    return {
+      chain: this.chain.name,
+      identifier: assetId,
+      name: assetBalance.name || assetId,
+      decimals: assetBalance.decimals || 6,
+      amount,
+      logoUrl: assetBalance.logo_url
+    };
+  }
+};
+
+// src/WarpFastsetExecutor.ts
+var import_warps2 = require("@vleap/warps");
+
+// src/WarpFastsetSerializer.ts
+var import_warps = require("@vleap/warps");
+var WarpFastsetSerializer = class {
+  constructor() {
+    this.coreSerializer = new import_warps.WarpSerializer();
+  }
+  typedToString(value) {
+    if (typeof value === "string") {
+      return `string:${value}`;
+    }
+    if (typeof value === "number") {
+      return `number:${value}`;
+    }
+    if (typeof value === "boolean") {
+      return `boolean:${value}`;
+    }
+    if (typeof value === "bigint") {
+      return `biguint:${value.toString()}`;
+    }
+    if (Array.isArray(value)) {
+      const items = value.map((item) => this.typedToString(item)).join(",");
+      return `array:${items}`;
+    }
+    if (value === null) {
+      return "null:null";
+    }
+    if (value === void 0) {
+      return "undefined:undefined";
+    }
+    return `string:${String(value)}`;
+  }
+  typedToNative(value) {
+    if (typeof value === "string") {
+      return ["string", value];
+    }
+    if (typeof value === "number") {
+      return ["number", value];
+    }
+    if (typeof value === "boolean") {
+      return ["boolean", value];
+    }
+    if (typeof value === "bigint") {
+      return ["biguint", value.toString()];
+    }
+    return ["string", String(value)];
+  }
+  nativeToTyped(type, value) {
+    switch (type) {
+      case "string":
+        return String(value);
+      case "number":
+        return Number(value);
+      case "boolean":
+        return Boolean(value);
+      case "biguint":
+        return BigInt(value);
+      case "address":
+        return String(value);
+      case "hex":
+        return String(value);
+      default:
+        return String(value);
+    }
+  }
+  nativeToType(type) {
+    switch (type) {
+      case "string":
+        return "string";
+      case "number":
+        return "number";
+      case "boolean":
+        return "boolean";
+      case "biguint":
+        return "biguint";
+      case "address":
+        return "address";
+      case "hex":
+        return "hex";
+      default:
+        return "string";
+    }
+  }
+  stringToTyped(value) {
+    const colonIndex = value.indexOf(":");
+    if (colonIndex === -1) {
+      return value;
+    }
+    const type = value.substring(0, colonIndex);
+    const stringValue = value.substring(colonIndex + 1);
+    switch (type) {
+      case "string":
+        return stringValue;
+      case "number":
+        return Number(stringValue);
+      case "boolean":
+        return stringValue === "true";
+      case "biguint":
+        return BigInt(stringValue);
+      case "array":
+        return stringValue.split(",").map((item) => this.stringToTyped(item));
+      case "null":
+        return null;
+      case "undefined":
+        return void 0;
+      default:
+        return stringValue;
+    }
+  }
+};
+
+// src/WarpFastsetExecutor.ts
+var WarpFastsetExecutor = class {
+  constructor(config, chain) {
+    this.config = config;
+    this.chain = chain;
+    this.serializer = new WarpFastsetSerializer();
+    const validatorUrl = (0, import_warps2.getProviderUrl)(this.config, chain.name, this.config.env, this.chain.defaultApiUrl);
+    const proxyUrl = (0, import_warps2.getProviderUrl)(this.config, chain.name, this.config.env, this.chain.defaultApiUrl);
+    this.fastsetClient = new FastsetClient({
+      validatorUrl,
+      proxyUrl
+    });
+  }
+  async createTransaction(executable) {
+    const action = (0, import_warps2.getWarpActionByIndex)(executable.warp, executable.action);
+    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];
+    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}`);
+    }
+    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,
+      amount,
+      userData,
+      chain: executable.chain
+    };
+  }
+  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 = (0, import_warps2.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 contractAddress = this.fromBase64(executable.destination);
+      const encodedData = this.encodeFunctionData(action.func, executable.args);
+      return {
+        type: "fastset-contract-call",
+        contract: contractAddress,
+        function: action.func,
+        data: encodedData,
+        value: executable.value,
+        chain: executable.chain
+      };
+    } catch (error) {
+      throw new Error(`WarpFastsetExecutor: Failed to encode function data for ${action.func}: ${error}`);
+    }
+  }
+  async executeQuery(executable) {
+    const action = (0, import_warps2.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 contractAddress = this.fromBase64(executable.destination);
+      const result = await this.executeFastsetQuery(contractAddress, action.func, executable.args);
+      return {
+        success: true,
+        result,
+        chain: executable.chain
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+        chain: executable.chain
+      };
+    }
+  }
+  async preprocessInput(chain, input, type, value) {
+    return value;
+  }
+  async signMessage(message, privateKey) {
+    throw new Error("Not implemented");
+  }
+  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 transactionHash = await this.fastsetClient.executeTransfer(
+      privateKeyBytes,
+      transaction.recipient,
+      transaction.amount,
+      transaction.userData
+    );
+    return {
+      success: true,
+      transactionHash: Array.from(transactionHash),
+      chain: executable.chain.name
+    };
+  }
+  encodeFunctionData(functionName, args) {
+    return JSON.stringify({
+      function: functionName,
+      arguments: args
+    });
+  }
+  async executeFastsetQuery(contractAddress, functionName, args) {
+    const validatorUrl = (0, import_warps2.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, _config) {
+    this._chainInfo = _chainInfo;
+    this._config = _config;
+    this.explorerUrl = "https://explorer.fastset.xyz";
+  }
+  getAccountUrl(address) {
+    return `${this.explorerUrl}/account/${address}`;
+  }
+  getTransactionUrl(hash) {
+    return `${this.explorerUrl}/transaction/${hash}`;
+  }
+  getAssetUrl(identifier) {
+    return `${this.explorerUrl}/asset/${identifier}`;
+  }
+  getContractUrl(address) {
+    return `${this.explorerUrl}/account/${address}`;
+  }
+};
+
+// src/WarpFastsetResults.ts
+var import_warps3 = require("@vleap/warps");
+var WarpFastsetResults = class {
+  constructor(config, chain) {
+    this.config = config;
+    this.chain = chain;
+    this.serializer = new WarpFastsetSerializer();
+  }
+  async getTransactionExecutionResults(warp, tx) {
+    const success = this.isTransactionSuccessful(tx);
+    const transactionHash = this.extractTransactionHash(tx);
+    const blockNumber = this.extractBlockNumber(tx);
+    const timestamp = this.extractTimestamp(tx);
+    return {
+      success,
+      warp,
+      action: 0,
+      user: this.config.user?.wallets?.[this.chain.name] || null,
+      txHash: transactionHash,
+      tx,
+      next: null,
+      values: [transactionHash, blockNumber, timestamp],
+      valuesRaw: [transactionHash, blockNumber, timestamp],
+      results: {},
+      messages: {}
+    };
+  }
+  async extractQueryResults(warp, typedValues, actionIndex, inputs) {
+    const values = typedValues.map((t) => this.serializer.typedToString(t));
+    const valuesRaw = typedValues.map((t) => this.serializer.typedToNative(t)[1]);
+    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]];
+      for (let i = 1; i < indices.length; i++) {
+        if (value === void 0 || value === null) return void 0;
+        value = value[indices[i]];
+      }
+      return value;
+    };
+    for (const [key, path] of Object.entries(warp.results)) {
+      if (path.startsWith(import_warps3.WarpConstants.Transform.Prefix)) continue;
+      const currentActionIndex = (0, import_warps3.parseResultsOutIndex)(path);
+      if (currentActionIndex !== null && currentActionIndex !== actionIndex) {
+        results[key] = null;
+        continue;
+      }
+      if (path.startsWith("out.") || path === "out" || path.startsWith("out[")) {
+        const value = getNestedValue(path);
+        results[key] = value || null;
+      } else {
+        results[key] = path;
+      }
+    }
+    return { values, results: await (0, import_warps3.evaluateResultsCommon)(warp, results, actionIndex, inputs, this.config.transform?.runner) };
+  }
+  isTransactionSuccessful(tx) {
+    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;
+  }
+  extractTransactionHash(tx) {
+    if (!tx) return "";
+    return tx.transaction_hash || tx.transactionHash || tx.hash || tx.result && tx.result.transaction_hash || "";
+  }
+  extractBlockNumber(tx) {
+    if (!tx) return "0";
+    return tx.block_number?.toString() || tx.blockNumber?.toString() || tx.result && tx.result.block_number?.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 NativeTokenSet = {
+  chain: import_warps4.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(import_warps4.WarpChainName.Fastset, "fastset", {
+  mainnet: {
+    name: import_warps4.WarpChainName.Fastset,
+    displayName: "FastSet",
+    chainId: "1",
+    blockTime: 1e3,
+    addressHrp: "set",
+    defaultApiUrl: "https://rpc.fastset.xyz",
+    nativeToken: NativeTokenSet
+  },
+  testnet: {
+    name: import_warps4.WarpChainName.Fastset,
+    displayName: "FastSet Testnet",
+    chainId: "testnet",
+    blockTime: 1e3,
+    addressHrp: "set",
+    defaultApiUrl: "https://rpc.fastset.xyz",
+    nativeToken: NativeTokenSet
+  },
+  devnet: {
+    name: import_warps4.WarpChainName.Fastset,
+    displayName: "FastSet Devnet",
+    chainId: "devnet",
+    blockTime: 1e3,
+    addressHrp: "set",
+    defaultApiUrl: "https://rpc.fastset.xyz",
+    nativeToken: NativeTokenSet
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Address,
+  Amount,
+  BcsTransaction,
+  Bytes32,
+  Claim,
+  ClaimType,
+  FastsetClient,
+  NativeTokenSet,
+  Nonce,
+  PublicKey,
+  Transaction,
+  Transfer,
+  TransferClaim,
+  UserData,
+  Wallet,
+  WarpFastsetConstants,
+  WarpFastsetDataLoader,
+  WarpFastsetExecutor,
+  WarpFastsetExplorer,
+  WarpFastsetResults,
+  WarpFastsetSerializer,
+  getFastsetAdapter
+});
+//# sourceMappingURL=index.js.map