@vleap/warps-adapter-fastset 0.1.0-alpha.8 → 0.1.0-alpha.9

package/dist/index.js

@@ -1,853 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  Address: () => Address,
-  Amount: () => Amount,
-  Bytes32: () => Bytes32,
-  ClaimType: () => ClaimType,
-  FastsetClient: () => FastsetClient,
-  Nonce: () => Nonce,
-  PublicKey: () => PublicKey,
-  Transaction: () => Transaction,
-  Transfer: () => Transfer,
-  UserData: () => UserData,
-  WarpFastsetConstants: () => WarpFastsetConstants,
-  WarpFastsetExecutor: () => WarpFastsetExecutor,
-  WarpFastsetExplorer: () => WarpFastsetExplorer,
-  WarpFastsetResults: () => WarpFastsetResults,
-  WarpFastsetSerializer: () => WarpFastsetSerializer,
-  decimalToHex: () => decimalToHex,
-  fromBase64: () => fromBase64,
-  getFastsetAdapter: () => getFastsetAdapter,
-  hexToDecimal: () => hexToDecimal2,
-  isValidFastsetAddress: () => isValidFastsetAddress,
-  normalizeAmount: () => normalizeAmount,
-  toBase64String: () => toBase64String,
-  toHexString: () => toHexString,
-  validateAmount: () => validateAmount,
-  validatePrivateKey: () => validatePrivateKey,
-  validatePublicKey: () => validatePublicKey
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/constants.ts
-var WarpFastsetConstants = {
-  Pi: {
-    Identifier: "PI",
-    DisplayName: "Pi",
-    Decimals: 18
-  },
-  GasLimit: {
-    Default: 21e3,
-    ContractCall: 1e5,
-    ContractDeploy: 5e5,
-    Transfer: 21e3,
-    Approve: 46e3,
-    Swap: 2e5
-  },
-  GasPrice: {
-    Default: "20000000000",
-    // 20 gwei
-    Low: "10000000000",
-    // 10 gwei
-    Medium: "20000000000",
-    // 20 gwei
-    High: "50000000000"
-    // 50 gwei
-  },
-  Validation: {
-    AddressLength: 42,
-    HexPrefix: "0x",
-    MinGasLimit: 21e3,
-    MaxGasLimit: 3e7
-  },
-  Timeouts: {
-    DefaultRpcTimeout: 3e4,
-    // 30 seconds
-    GasEstimationTimeout: 1e4,
-    // 10 seconds
-    QueryTimeout: 15e3
-    // 15 seconds
-  }
-};
-
-// src/WarpFastsetDataLoader.ts
-var WarpFastsetDataLoader = class {
-  constructor(config, chain) {
-    this.config = config;
-    this.chain = chain;
-  }
-  async getAccount(address) {
-    return {
-      address,
-      balance: BigInt(0)
-      // TODO: Implement actual balance fetching from Fastset API
-    };
-  }
-  async getAccountAssets(address) {
-    return [];
-  }
-};
-
-// src/WarpFastsetExecutor.ts
-var import_warps2 = require("@vleap/warps");
-
-// src/config.ts
-var FASTSET_CHAIN_CONFIGS = {
-  fastset: {
-    mainnet: {
-      apiUrl: "http://157.90.201.117:8765",
-      proxyUrl: "http://136.243.61.168:44444",
-      explorerUrl: "https://explorer.fastset.com",
-      chainId: "1",
-      registryAddress: "0x0000000000000000000000000000000000000000",
-      nativeToken: "PI",
-      blockTime: 12e3
-    },
-    testnet: {
-      apiUrl: "http://157.90.201.117:8765",
-      proxyUrl: "http://136.243.61.168:44444",
-      explorerUrl: "https://testnet-explorer.fastset.com",
-      chainId: "11155111",
-      registryAddress: "0x0000000000000000000000000000000000000000",
-      nativeToken: "PI",
-      blockTime: 12e3
-    },
-    devnet: {
-      apiUrl: "http://157.90.201.117:8765",
-      proxyUrl: "http://136.243.61.168:44444",
-      explorerUrl: "http://localhost:4000",
-      chainId: "1337",
-      registryAddress: "0x0000000000000000000000000000000000000000",
-      nativeToken: "PI",
-      blockTime: 12e3
-    }
-  }
-};
-var DEFAULT_CHAIN = "fastset";
-var getFastsetChainConfig = (chain = DEFAULT_CHAIN, env) => {
-  const chainConfigs = FASTSET_CHAIN_CONFIGS[chain];
-  if (!chainConfigs) {
-    throw new Error(`Unsupported Fastset chain: ${chain}`);
-  }
-  const config = chainConfigs[env];
-  if (!config) {
-    throw new Error(`Unsupported environment ${env} for chain ${chain}`);
-  }
-  return config;
-};
-var getFastsetApiUrl = (env, chain = DEFAULT_CHAIN) => {
-  return getFastsetChainConfig(chain, env).apiUrl;
-};
-var getFastsetProxyUrl = (env, chain = DEFAULT_CHAIN) => {
-  return getFastsetChainConfig(chain, env).proxyUrl;
-};
-
-// src/sdk/FastsetClient.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 Transaction = 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/FastsetClient.ts
-var FastsetClient = class {
-  constructor(config) {
-    this.config = config;
-  }
-  async getAccountInfo(address) {
-    try {
-      const response = await this.requestValidator("set_getAccountInfo", {
-        address: Array.from(address)
-      });
-      if (response.error) {
-        return null;
-      }
-      return response.result;
-    } catch (error) {
-      return null;
-    }
-  }
-  async getNextNonce(senderAddress) {
-    const accountInfo = await this.getAccountInfo(senderAddress);
-    return accountInfo?.next_nonce ?? 0;
-  }
-  async fundFromFaucet(request) {
-    const response = await this.requestProxy("faucetDrip", {
-      recipient: Array.from(request.recipient),
-      amount: request.amount
-    });
-    if (response.error) {
-      throw new Error(`Faucet request failed: ${response.error.message}`);
-    }
-    return response.result;
-  }
-  async submitTransaction(request) {
-    const response = await this.requestValidator("set_submitTransaction", {
-      transaction: this.serializeTransaction(request.transaction),
-      signature: Array.from(request.signature)
-    });
-    if (response.error) {
-      throw new Error(`Transaction submission failed: ${response.error.message}`);
-    }
-    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) {
-    const response = await this.requestValidator("set_submitTransactionCertificate", {
-      transaction: this.serializeTransaction(request.transaction),
-      signature: Array.from(request.signature),
-      validator_signatures: request.validator_signatures.map(([validator, signature]) => [Array.from(validator), Array.from(signature)])
-    });
-    if (response.error) {
-      throw new Error(`Certificate submission failed: ${response.error.message}`);
-    }
-  }
-  async executeTransfer(senderPrivateKey, recipient, amount, userData) {
-    const senderPublicKey = await (0, import_ed25519.getPublicKey)(senderPrivateKey);
-    const nonce = await this.getNextNonce(senderPublicKey);
-    const transaction = {
-      sender: senderPublicKey,
-      nonce,
-      timestamp_nanos: BigInt(Date.now()) * 1000000n,
-      claim: {
-        Transfer: {
-          recipient: { FastSet: recipient },
-          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 signTransaction(transaction, privateKey) {
-    const msg = Transaction.serialize(transaction);
-    const msgBytes = msg.toBytes();
-    const prefix = new TextEncoder().encode("Transaction::");
-    const dataToSign = new Uint8Array(prefix.length + msgBytes.length);
-    dataToSign.set(prefix, 0);
-    dataToSign.set(msgBytes, prefix.length);
-    return (0, import_ed25519.sign)(dataToSign, privateKey);
-  }
-  serializeTransaction(transaction) {
-    return JSON.stringify(transaction, this.jsonReplacer);
-  }
-  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) {
-    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}`);
-    }
-    return response.json();
-  }
-  jsonReplacer(key, value) {
-    if (value instanceof Uint8Array) {
-      return Array.from(value);
-    }
-    return value;
-  }
-};
-
-// src/sdk/utils.ts
-var import_bcs2 = require("@mysten/bcs");
-function isValidFastsetAddress(address) {
-  if (typeof address !== "string" || address.length === 0) {
-    return false;
-  }
-  if (address.startsWith("fs") || address.startsWith("pi")) {
-    return true;
-  }
-  try {
-    const decoded = fromBase64(address);
-    return decoded.length === 32;
-  } catch {
-    return false;
-  }
-}
-function fromBase64(base64) {
-  return new Uint8Array(Buffer.from(base64, "base64"));
-}
-function toBase64String(bytes) {
-  return (0, import_bcs2.toB64)(bytes);
-}
-function toHexString(bytes) {
-  return (0, import_bcs2.toHEX)(bytes);
-}
-function hexToDecimal2(hex) {
-  return BigInt(`0x${hex}`).toString();
-}
-function decimalToHex(decimal) {
-  return BigInt(decimal).toString(16);
-}
-function validateAmount(amount) {
-  try {
-    const bigInt = BigInt(amount);
-    return bigInt >= 0;
-  } catch {
-    return false;
-  }
-}
-function normalizeAmount(amount) {
-  try {
-    const bigInt = BigInt(amount);
-    return bigInt.toString(16);
-  } catch {
-    throw new Error(`Invalid amount format: ${amount}`);
-  }
-}
-function validatePrivateKey(privateKey) {
-  try {
-    const key = typeof privateKey === "string" ? fromBase64(privateKey) : privateKey;
-    return key.length === 32;
-  } catch {
-    return false;
-  }
-}
-function validatePublicKey(publicKey) {
-  try {
-    const key = typeof publicKey === "string" ? fromBase64(publicKey) : publicKey;
-    return key.length === 32;
-  } catch {
-    return false;
-  }
-}
-
-// 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 `bigint:${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 ["bigint", value];
-    }
-    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 "bigint":
-        return BigInt(value);
-      default:
-        return String(value);
-    }
-  }
-  nativeToType(type) {
-    switch (type) {
-      case "string":
-        return "string";
-      case "number":
-        return "number";
-      case "boolean":
-        return "boolean";
-      case "bigint":
-        return "bigint";
-      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 "bigint":
-        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) {
-    this.config = config;
-    this.serializer = new WarpFastsetSerializer();
-    this.fastsetClient = new FastsetClient({
-      validatorUrl: getFastsetApiUrl(this.config.env, "fastset"),
-      proxyUrl: getFastsetProxyUrl(this.config.env, "fastset")
-    });
-  }
-  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 (!isValidFastsetAddress(executable.destination)) {
-      throw new Error(`WarpFastsetExecutor: Invalid destination address: ${executable.destination}`);
-    }
-    if (executable.value < 0) {
-      throw new Error(`WarpFastsetExecutor: Transfer value cannot be negative: ${executable.value}`);
-    }
-    const recipientAddress = fromBase64(executable.destination);
-    const amount = normalizeAmount(executable.value.toString());
-    const userData = executable.data ? fromBase64(this.serializer.stringToTyped(executable.data)) : void 0;
-    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 (!isValidFastsetAddress(executable.destination)) {
-      throw new Error(`WarpFastsetExecutor: Invalid contract address: ${executable.destination}`);
-    }
-    if (executable.value < 0) {
-      throw new Error(`WarpFastsetExecutor: Contract call value cannot be negative: ${executable.value}`);
-    }
-    try {
-      const contractAddress = fromBase64(executable.destination);
-      const 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 (!isValidFastsetAddress(executable.destination)) {
-      throw new Error(`WarpFastsetExecutor: Invalid contract address for query: ${executable.destination}`);
-    }
-    try {
-      const contractAddress = 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) {
-    const typedValue = this.serializer.stringToTyped(value);
-    switch (type) {
-      case "address":
-        if (!isValidFastsetAddress(typedValue)) {
-          throw new Error(`Invalid Fastset address format: ${typedValue}`);
-        }
-        return typedValue;
-      case "hex":
-        const hexValue = typedValue.startsWith("0x") ? typedValue.slice(2) : typedValue;
-        if (!/^[0-9a-fA-F]+$/.test(hexValue)) {
-          throw new Error(`Invalid hex format: ${typedValue}`);
-        }
-        return typedValue;
-      case "number":
-        const numValue = Number(typedValue);
-        if (isNaN(numValue)) {
-          throw new Error(`Invalid number format: ${typedValue}`);
-        }
-        return numValue.toString();
-      case "biguint":
-        const bigIntValue = BigInt(typedValue);
-        if (bigIntValue < 0) {
-          throw new Error(`Negative value not allowed`);
-        }
-        return bigIntValue.toString();
-      default:
-        return String(typedValue);
-    }
-  }
-  encodeFunctionData(functionName, args) {
-    return JSON.stringify({
-      function: functionName,
-      arguments: args
-    });
-  }
-  async executeFastsetQuery(contractAddress, functionName, args) {
-    const response = await fetch(`${getFastsetApiUrl(this.config.env, "fastset")}/query`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
-        contract: Array.from(contractAddress),
-        function: functionName,
-        arguments: args
-      })
-    });
-    if (!response.ok) {
-      throw new Error(`Fastset query failed: ${response.statusText}`);
-    }
-    return response.json();
-  }
-  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 = 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
-    };
-  }
-};
-
-// src/WarpFastsetExplorer.ts
-var WarpFastsetExplorer = class {
-  constructor(chainInfo) {
-    this.chainInfo = chainInfo;
-  }
-  getAccountUrl(address) {
-    const baseUrl = this.getDefaultExplorerUrl();
-    return `${baseUrl}/address/${address}`;
-  }
-  getTransactionUrl(hash) {
-    const baseUrl = this.getDefaultExplorerUrl();
-    return `${baseUrl}/tx/${hash}`;
-  }
-  getBlockUrl(blockNumber) {
-    const baseUrl = this.getDefaultExplorerUrl();
-    return `${baseUrl}/block/${blockNumber}`;
-  }
-  getContractUrl(address) {
-    const baseUrl = this.getDefaultExplorerUrl();
-    return `${baseUrl}/contract/${address}`;
-  }
-  getAssetUrl(identifier) {
-    const baseUrl = this.getDefaultExplorerUrl();
-    return `${baseUrl}/token/${identifier}`;
-  }
-  getDefaultExplorerUrl() {
-    return `https://explorer.fastset.xyz`;
-  }
-};
-
-// src/WarpFastsetResults.ts
-var import_warps3 = require("@vleap/warps");
-var WarpFastsetResults = class {
-  constructor(config) {
-    this.config = config;
-    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);
-    return {
-      success,
-      warp,
-      action: 0,
-      user: this.config.user?.wallets?.fastset || null,
-      txHash: transactionHash,
-      next: null,
-      values: [transactionHash, blockNumber, gasUsed, gasPrice, ...logs.length > 0 ? logs : []],
-      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 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[")) {
-        results[key] = getNestedValue(path) || null;
-      } else {
-        results[key] = path;
-      }
-    }
-    return { values, results: await (0, import_warps3.evaluateResultsCommon)(warp, results, actionIndex, inputs) };
-  }
-  isTransactionSuccessful(tx) {
-    return tx.status === "success" || tx.status === 1 || tx.success === true;
-  }
-  extractGasUsed(tx) {
-    return tx.gasUsed?.toString() || tx.gas_used?.toString() || "0";
-  }
-  extractGasPrice(tx) {
-    return tx.gasPrice?.toString() || tx.gas_price?.toString() || "0";
-  }
-  extractBlockNumber(tx) {
-    return tx.blockNumber?.toString() || tx.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"
-    }));
-  }
-};
-
-// src/main.ts
-var ChainName = "fastset";
-var getFastsetAdapter = (config, fallback) => {
-  if (!fallback) throw new Error("Fastset adapter requires a fallback adapter");
-  const chainInfo = {
-    name: ChainName,
-    displayName: "FastSet",
-    chainId: "1",
-    blockTime: 100,
-    addressHrp: "set",
-    apiUrl: "TODO",
-    nativeToken: "SET"
-  };
-  return {
-    chain: ChainName,
-    chainInfo,
-    prefix: "fastset",
-    builder: () => fallback.builder(),
-    executor: new WarpFastsetExecutor(config),
-    results: new WarpFastsetResults(config),
-    serializer: new WarpFastsetSerializer(),
-    registry: fallback.registry,
-    explorer: new WarpFastsetExplorer(chainInfo),
-    abiBuilder: () => fallback.abiBuilder(),
-    brandBuilder: () => fallback.brandBuilder(),
-    dataLoader: new WarpFastsetDataLoader(config, chainInfo)
-  };
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  Address,
-  Amount,
-  Bytes32,
-  ClaimType,
-  FastsetClient,
-  Nonce,
-  PublicKey,
-  Transaction,
-  Transfer,
-  UserData,
-  WarpFastsetConstants,
-  WarpFastsetExecutor,
-  WarpFastsetExplorer,
-  WarpFastsetResults,
-  WarpFastsetSerializer,
-  decimalToHex,
-  fromBase64,
-  getFastsetAdapter,
-  hexToDecimal,
-  isValidFastsetAddress,
-  normalizeAmount,
-  toBase64String,
-  toHexString,
-  validateAmount,
-  validatePrivateKey,
-  validatePublicKey
-});
-//# sourceMappingURL=index.js.map