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

package/dist/index.mjs

@@ -1,7 +1,5 @@
 // src/constants.ts
 var WarpFastsetConstants = {
-  ChainName: "fastset",
-  ChainPrefix: "fastset",
   Pi: {
     Identifier: "PI",
     DisplayName: "Pi",
@@ -25,23 +23,6 @@ var WarpFastsetConstants = {
     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",
@@ -183,28 +164,31 @@ import {
 var FASTSET_CHAIN_CONFIGS = {
   fastset: {
     mainnet: {
-      apiUrl: "https://mainnet.fastset.com/api",
+      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: 12
+      blockTime: 12e3
     },
     testnet: {
-      apiUrl: "https://testnet.fastset.com/api",
+      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: 12
+      blockTime: 12e3
     },
     devnet: {
-      apiUrl: "http://localhost:8545",
+      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: 12
+      blockTime: 12e3
     }
   }
 };
@@ -223,6 +207,238 @@ var getFastsetChainConfig = (chain = DEFAULT_CHAIN, env) => {
 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
+import { getPublicKey, sign } from "@noble/ed25519";
+
+// src/sdk/types.ts
+import { bcs } from "@mysten/bcs";
+BigInt.prototype.toJSON = function() {
+  return Number(this);
+};
+var Bytes32 = bcs.fixedArray(32, bcs.u8());
+var PublicKey = Bytes32;
+var Address = bcs.enum("Address", {
+  External: PublicKey,
+  FastSet: PublicKey
+});
+var Amount = bcs.u256().transform({
+  input: (val) => hexToDecimal(val.toString()),
+  output: (value) => value
+});
+var UserData = bcs.option(Bytes32);
+var Nonce = bcs.u64();
+var Transfer = bcs.struct("Transfer", {
+  recipient: Address,
+  amount: Amount,
+  user_data: UserData
+});
+var ClaimType = bcs.enum("ClaimType", {
+  Transfer
+});
+var Transaction = bcs.struct("Transaction", {
+  sender: PublicKey,
+  nonce: Nonce,
+  timestamp_nanos: 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 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 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
+import { toBase64, toHex } from "@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 toBase64(bytes);
+}
+function toHexString(bytes) {
+  return 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
 import {
@@ -333,63 +549,69 @@ 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 = 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];
+    const userWallet = this.config.user?.wallets?.[executable.chain];
     if (!userWallet) throw new Error("WarpFastsetExecutor: createTransfer - user address not set");
-    if (!this.isValidFastsetAddress(executable.destination)) {
+    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",
-      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) {
-    const userWallet = this.config.user?.wallets?.[executable.chain.name];
+    const userWallet = this.config.user?.wallets?.[executable.chain];
     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)) {
+    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",
-        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}`);
@@ -403,21 +625,22 @@ var WarpFastsetExecutor = class {
     if (!action.func) {
       throw new Error("WarpFastsetExecutor: Query action must have a function name");
     }
-    if (!this.isValidFastsetAddress(executable.destination)) {
+    if (!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);
+      const contractAddress = 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
       };
     }
   }
@@ -425,29 +648,32 @@ var WarpFastsetExecutor = class {
     const typedValue = this.serializer.stringToTyped(value);
     switch (type) {
       case "address":
-        if (!this.isValidFastsetAddress(typedValue)) {
+        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 "bigint":
+      case "biguint":
         const bigIntValue = BigInt(typedValue);
         if (bigIntValue < 0) {
-          throw new Error(`Negative value not allowed for type ${type}: ${typedValue}`);
+          throw new Error(`Negative value not allowed`);
         }
         return bigIntValue.toString();
       default:
         return String(typedValue);
     }
   }
-  isValidFastsetAddress(address) {
-    return typeof address === "string" && address.length > 0;
-  }
   encodeFunctionData(functionName, args) {
     return JSON.stringify({
       function: functionName,
@@ -461,7 +687,7 @@ var WarpFastsetExecutor = class {
         "Content-Type": "application/json"
       },
       body: JSON.stringify({
-        contract: contractAddress,
+        contract: Array.from(contractAddress),
         function: functionName,
         arguments: args
       })
@@ -474,32 +700,59 @@ var WarpFastsetExecutor = class {
   async signMessage(message, privateKey) {
     throw new Error("Not implemented");
   }
+  async executeTransfer(executable) {
+    const userWallet = this.config.user?.wallets?.[executable.chain];
+    if (!userWallet) throw new Error("WarpFastsetExecutor: executeTransfer - user wallet not set");
+    const transaction = await this.createTransferTransaction(executable);
+    return {
+      success: true,
+      transaction,
+      chain: executable.chain,
+      message: "Transaction created successfully. Use executeTransferWithKey to execute with private key."
+    };
+  }
+  async executeTransferWithKey(executable, privateKey) {
+    const userWallet = this.config.user?.wallets?.[executable.chain];
+    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
+    };
+  }
 };
 
 // src/WarpFastsetExplorer.ts
 var WarpFastsetExplorer = class {
-  constructor(chainInfo, chainName = "fastset") {
+  constructor(chainInfo) {
     this.chainInfo = chainInfo;
-    this.chainName = chainName;
   }
   getAccountUrl(address) {
-    const baseUrl = this.chainInfo.explorerUrl || this.getDefaultExplorerUrl();
+    const baseUrl = this.getDefaultExplorerUrl();
     return `${baseUrl}/address/${address}`;
   }
   getTransactionUrl(hash) {
-    const baseUrl = this.chainInfo.explorerUrl || this.getDefaultExplorerUrl();
+    const baseUrl = this.getDefaultExplorerUrl();
     return `${baseUrl}/tx/${hash}`;
   }
   getBlockUrl(blockNumber) {
-    const baseUrl = this.chainInfo.explorerUrl || this.getDefaultExplorerUrl();
+    const baseUrl = this.getDefaultExplorerUrl();
     return `${baseUrl}/block/${blockNumber}`;
   }
   getContractUrl(address) {
-    const baseUrl = this.chainInfo.explorerUrl || this.getDefaultExplorerUrl();
+    const baseUrl = this.getDefaultExplorerUrl();
     return `${baseUrl}/contract/${address}`;
   }
   getTokenUrl(address) {
-    const baseUrl = this.chainInfo.explorerUrl || this.getDefaultExplorerUrl();
+    const baseUrl = this.getDefaultExplorerUrl();
     return `${baseUrl}/token/${address}`;
   }
   getDefaultExplorerUrl() {
@@ -596,28 +849,59 @@ var WarpFastsetResults = class {
 };
 
 // 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: WarpFastsetConstants.ChainName,
-    prefix: WarpFastsetConstants.ChainPrefix,
+    chain: ChainName,
+    chainInfo,
+    prefix: "fastset",
     builder: () => new WarpFastsetBuilder(config),
     executor: new WarpFastsetExecutor(config),
     results: new WarpFastsetResults(config),
     serializer: new WarpFastsetSerializer(),
     registry: fallback.registry,
-    explorer: (chainInfo) => new WarpFastsetExplorer(chainInfo),
+    explorer: new WarpFastsetExplorer(chainInfo),
     abiBuilder: () => fallback.abiBuilder(),
     brandBuilder: () => fallback.brandBuilder()
   };
 };
 export {
+  Address,
+  Amount,
+  Bytes32,
+  ClaimType,
+  FastsetClient,
+  Nonce,
+  PublicKey,
+  Transaction,
+  Transfer,
+  UserData,
   WarpFastsetBuilder,
   WarpFastsetConstants,
   WarpFastsetExecutor,
   WarpFastsetExplorer,
   WarpFastsetResults,
   WarpFastsetSerializer,
-  getFastsetAdapter
+  decimalToHex,
+  fromBase64,
+  getFastsetAdapter,
+  hexToDecimal2 as hexToDecimal,
+  isValidFastsetAddress,
+  normalizeAmount,
+  toBase64String,
+  toHexString,
+  validateAmount,
+  validatePrivateKey,
+  validatePublicKey
 };
 //# sourceMappingURL=index.mjs.map