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

package/dist/index.mjs

@@ -0,0 +1,623 @@
+// 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
+  }
+};
+
+// 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}`);
+    }
+  }
+  setTitle(title) {
+    this.warp.title = title;
+    return this;
+  }
+  setDescription(description) {
+    this.warp.description = description;
+    return this;
+  }
+  setPreview(preview) {
+    this.warp.preview = preview;
+    return this;
+  }
+  setActions(actions) {
+    this.actions = actions;
+    return this;
+  }
+  addAction(action) {
+    this.actions.push(action);
+    return this;
+  }
+  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()
+      }
+    };
+  }
+  createInscriptionTransaction(warp) {
+    return {
+      type: "fastset-inscription",
+      data: JSON.stringify(warp)
+      // TODO: Add Fastset-specific transaction fields
+    };
+  }
+  async createFromTransaction(tx, validate = true) {
+    try {
+      const warpData = tx.data || tx.payload || tx.content;
+      if (!warpData) {
+        throw new Error("No warp data found in transaction");
+      }
+      const parsed = typeof warpData === "string" ? JSON.parse(warpData) : warpData;
+      if (validate) {
+        this.validateWarp(parsed);
+      }
+      return parsed;
+    } catch (error) {
+      throw new Error(`Failed to create warp from Fastset transaction: ${error}`);
+    }
+  }
+  async createFromTransactionHash(hash, cache) {
+    try {
+      const tx = await this.fetchTransaction(hash);
+      if (!tx) {
+        return null;
+      }
+      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 fetchTransaction(hash) {
+    const response = await fetch(`${this.getApiUrl()}/transaction/${hash}`);
+    if (!response.ok) {
+      return null;
+    }
+    return response.json();
+  }
+  getApiUrl() {
+    return "https://api.fastset.xyz";
+  }
+};
+
+// src/WarpFastsetExecutor.ts
+import {
+  getWarpActionByIndex
+} from "@vleap/warps";
+
+// src/config.ts
+var FASTSET_CHAIN_CONFIGS = {
+  fastset: {
+    mainnet: {
+      apiUrl: "https://mainnet.fastset.com/api",
+      explorerUrl: "https://explorer.fastset.com",
+      chainId: "1",
+      registryAddress: "0x0000000000000000000000000000000000000000",
+      nativeToken: "PI",
+      blockTime: 12
+    },
+    testnet: {
+      apiUrl: "https://testnet.fastset.com/api",
+      explorerUrl: "https://testnet-explorer.fastset.com",
+      chainId: "11155111",
+      registryAddress: "0x0000000000000000000000000000000000000000",
+      nativeToken: "PI",
+      blockTime: 12
+    },
+    devnet: {
+      apiUrl: "http://localhost:8545",
+      explorerUrl: "http://localhost:4000",
+      chainId: "1337",
+      registryAddress: "0x0000000000000000000000000000000000000000",
+      nativeToken: "PI",
+      blockTime: 12
+    }
+  }
+};
+var DEFAULT_CHAIN = "fastset";
+var getFastsetChainConfig = (chain = DEFAULT_CHAIN, env) => {
+  const chainConfigs = FASTSET_CHAIN_CONFIGS[chain];
+  if (!chainConfigs) {
+    throw new Error(`Unsupported Fastset chain: ${chain}`);
+  }
+  const config = chainConfigs[env];
+  if (!config) {
+    throw new Error(`Unsupported environment ${env} for chain ${chain}`);
+  }
+  return config;
+};
+var getFastsetApiUrl = (env, chain = DEFAULT_CHAIN) => {
+  return getFastsetChainConfig(chain, env).apiUrl;
+};
+
+// src/WarpFastsetSerializer.ts
+import {
+  WarpSerializer
+} from "@vleap/warps";
+var WarpFastsetSerializer = class {
+  constructor() {
+    this.coreSerializer = new 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();
+  }
+  async createTransaction(executable) {
+    const action = getWarpActionByIndex(executable.warp, executable.action);
+    let tx = null;
+    if (action.type === "transfer") {
+      tx = await this.createTransferTransaction(executable);
+    } else if (action.type === "contract") {
+      tx = await this.createContractCallTransaction(executable);
+    } else if (action.type === "query") {
+      throw new Error("WarpFastsetExecutor: Invalid action type for createTransaction; Use executeQuery instead");
+    } else if (action.type === "collect") {
+      throw new Error("WarpFastsetExecutor: Invalid action type for createTransaction; Use executeCollect instead");
+    }
+    if (!tx) throw new Error(`WarpFastsetExecutor: Invalid action type (${action.type})`);
+    return tx;
+  }
+  async createTransferTransaction(executable) {
+    const userWallet = this.config.user?.wallets?.[executable.chain.name];
+    if (!userWallet) throw new Error("WarpFastsetExecutor: createTransfer - user address not set");
+    if (!this.isValidFastsetAddress(executable.destination)) {
+      throw new Error(`WarpFastsetExecutor: Invalid destination address: ${executable.destination}`);
+    }
+    if (executable.value < 0) {
+      throw new Error(`WarpFastsetExecutor: Transfer value cannot be negative: ${executable.value}`);
+    }
+    return {
+      type: "fastset-transfer",
+      from: userWallet,
+      to: executable.destination,
+      value: executable.value,
+      data: executable.data ? this.serializer.stringToTyped(executable.data) : ""
+      // TODO: Add Fastset-specific transaction fields
+    };
+  }
+  async createContractCallTransaction(executable) {
+    const userWallet = this.config.user?.wallets?.[executable.chain.name];
+    if (!userWallet) throw new Error("WarpFastsetExecutor: createContractCall - user address not set");
+    const action = getWarpActionByIndex(executable.warp, executable.action);
+    if (!action || !("func" in action) || !action.func) {
+      throw new Error("WarpFastsetExecutor: Contract action must have a function name");
+    }
+    if (!this.isValidFastsetAddress(executable.destination)) {
+      throw new Error(`WarpFastsetExecutor: Invalid contract address: ${executable.destination}`);
+    }
+    if (executable.value < 0) {
+      throw new Error(`WarpFastsetExecutor: Contract call value cannot be negative: ${executable.value}`);
+    }
+    try {
+      const encodedData = this.encodeFunctionData(action.func, executable.args);
+      return {
+        type: "fastset-contract-call",
+        from: userWallet,
+        to: executable.destination,
+        value: executable.value,
+        data: encodedData,
+        function: action.func
+        // TODO: Add Fastset-specific transaction fields
+      };
+    } catch (error) {
+      throw new Error(`WarpFastsetExecutor: Failed to encode function data for ${action.func}: ${error}`);
+    }
+  }
+  async executeQuery(executable) {
+    const action = getWarpActionByIndex(executable.warp, executable.action);
+    if (action.type !== "query") {
+      throw new Error(`WarpFastsetExecutor: Invalid action type for executeQuery: ${action.type}`);
+    }
+    if (!action.func) {
+      throw new Error("WarpFastsetExecutor: Query action must have a function name");
+    }
+    if (!this.isValidFastsetAddress(executable.destination)) {
+      throw new Error(`WarpFastsetExecutor: Invalid contract address for query: ${executable.destination}`);
+    }
+    try {
+      const result = await this.executeFastsetQuery(executable.destination, action.func, executable.args);
+      return {
+        success: true,
+        result
+        // TODO: Add Fastset-specific result fields
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+        // TODO: Add Fastset-specific error fields
+      };
+    }
+  }
+  async preprocessInput(chain, input, type, value) {
+    const typedValue = this.serializer.stringToTyped(value);
+    switch (type) {
+      case "address":
+        if (!this.isValidFastsetAddress(typedValue)) {
+          throw new Error(`Invalid Fastset address format: ${typedValue}`);
+        }
+        return typedValue;
+      case "number":
+        const numValue = Number(typedValue);
+        if (isNaN(numValue)) {
+          throw new Error(`Invalid number format: ${typedValue}`);
+        }
+        return numValue.toString();
+      case "bigint":
+        const bigIntValue = BigInt(typedValue);
+        if (bigIntValue < 0) {
+          throw new Error(`Negative value not allowed for type ${type}: ${typedValue}`);
+        }
+        return bigIntValue.toString();
+      default:
+        return String(typedValue);
+    }
+  }
+  isValidFastsetAddress(address) {
+    return typeof address === "string" && address.length > 0;
+  }
+  encodeFunctionData(functionName, args) {
+    return JSON.stringify({
+      function: functionName,
+      arguments: args
+    });
+  }
+  async executeFastsetQuery(contractAddress, functionName, args) {
+    const response = await fetch(`${getFastsetApiUrl(this.config.env, "fastset")}/query`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        contract: contractAddress,
+        function: functionName,
+        arguments: args
+      })
+    });
+    if (!response.ok) {
+      throw new Error(`Fastset query failed: ${response.statusText}`);
+    }
+    return response.json();
+  }
+  async signMessage(message, privateKey) {
+    throw new Error("Not implemented");
+  }
+};
+
+// src/WarpFastsetExplorer.ts
+var WarpFastsetExplorer = class {
+  constructor(chainInfo, chainName = "fastset") {
+    this.chainInfo = chainInfo;
+    this.chainName = chainName;
+  }
+  getAccountUrl(address) {
+    const baseUrl = this.chainInfo.explorerUrl || this.getDefaultExplorerUrl();
+    return `${baseUrl}/address/${address}`;
+  }
+  getTransactionUrl(hash) {
+    const baseUrl = this.chainInfo.explorerUrl || this.getDefaultExplorerUrl();
+    return `${baseUrl}/tx/${hash}`;
+  }
+  getBlockUrl(blockNumber) {
+    const baseUrl = this.chainInfo.explorerUrl || this.getDefaultExplorerUrl();
+    return `${baseUrl}/block/${blockNumber}`;
+  }
+  getContractUrl(address) {
+    const baseUrl = this.chainInfo.explorerUrl || this.getDefaultExplorerUrl();
+    return `${baseUrl}/contract/${address}`;
+  }
+  getTokenUrl(address) {
+    const baseUrl = this.chainInfo.explorerUrl || this.getDefaultExplorerUrl();
+    return `${baseUrl}/token/${address}`;
+  }
+  getDefaultExplorerUrl() {
+    return `https://explorer.fastset.xyz`;
+  }
+};
+
+// src/WarpFastsetResults.ts
+import {
+  evaluateResultsCommon,
+  parseResultsOutIndex,
+  WarpConstants
+} from "@vleap/warps";
+var WarpFastsetResults = class {
+  constructor(config) {
+    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(WarpConstants.Transform.Prefix)) continue;
+      const currentActionIndex = 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 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 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()
+  };
+};
+export {
+  WarpFastsetBuilder,
+  WarpFastsetConstants,
+  WarpFastsetExecutor,
+  WarpFastsetExplorer,
+  WarpFastsetResults,
+  WarpFastsetSerializer,
+  getFastsetAdapter
+};
+//# sourceMappingURL=index.mjs.map