@vleap/warps-adapter-fastset 0.1.0-alpha.24 → 0.1.0-alpha.25

package/dist/index.js

@@ -5,9 +5,6 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -30,175 +27,10 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/sdk/ed25519-setup.ts
-var ed, import_sha512;
-var init_ed25519_setup = __esm({
-  "src/sdk/ed25519-setup.ts"() {
-    "use strict";
-    ed = __toESM(require("@noble/ed25519"), 1);
-    import_sha512 = require("@noble/hashes/sha512");
-    if (ed.etc) {
-      ed.etc.sha512Sync = (...m) => (0, import_sha512.sha512)(ed.etc.concatBytes(...m));
-    }
-  }
-});
-
-// src/sdk/FastsetClient.ts
-var bech32, Transaction, FastsetClient, Wallet;
-var init_FastsetClient = __esm({
-  "src/sdk/FastsetClient.ts"() {
-    "use strict";
-    bech32 = __toESM(require("bech32"), 1);
-    init_ed25519_setup();
-    BigInt.prototype.toJSON = function() {
-      return Number(this);
-    };
-    Transaction = class {
-      constructor(sender, recipient, nonce, claim, timestamp = BigInt(Date.now()) * 1000000n) {
-        this.sender = sender;
-        this.recipient = recipient;
-        this.nonce = nonce;
-        this.claim = claim;
-        this.timestamp = timestamp;
-        if (claim?.Transfer?.amount?.startsWith("0x")) {
-          claim = { ...claim, Transfer: { ...claim.Transfer, amount: claim.Transfer.amount.slice(2) } };
-        }
-      }
-      toTransaction() {
-        return { sender: this.sender, recipient: this.recipient, nonce: this.nonce, timestamp_nanos: this.timestamp, claim: this.claim };
-      }
-      getRecipientAddress() {
-        return this.recipient;
-      }
-      getAmount() {
-        return this.claim?.Transfer?.amount || "";
-      }
-      getUserData() {
-        return this.claim?.Transfer?.user_data || null;
-      }
-    };
-    FastsetClient = class {
-      constructor(config, chain) {
-        this.proxyUrl = config && "proxyUrl" in config ? config.proxyUrl : config && chain ? chain.defaultApiUrl : "https://proxy.fastset.xyz";
-      }
-      async makeRequest(method, params = {}) {
-        const response = await fetch(this.proxyUrl, {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({ jsonrpc: "2.0", method, params, id: Date.now() }, (k, v) => v instanceof Uint8Array ? Array.from(v) : v)
-        });
-        if (!response.ok) throw new Error(`HTTP error! status: ${response.status}`);
-        const jsonResponse = await response.json();
-        if (jsonResponse.error) throw new Error(`JSON-RPC error ${jsonResponse.error.code}: ${jsonResponse.error.message}`);
-        return jsonResponse.result;
-      }
-      async getAccountInfo(address) {
-        return this.makeRequest("set_proxy_getAccountInfo", { address });
-      }
-      async getNextNonce(address) {
-        const addressBytes = typeof address === "string" ? this.addressToBytes(address) : address;
-        const accountInfo = await this.getAccountInfo(addressBytes);
-        return accountInfo.next_nonce;
-      }
-      async submitTransaction(transaction, signature) {
-        const signatureArray = Array.isArray(signature) ? signature : Array.from(signature);
-        const submitTxReq = {
-          transaction: {
-            sender: transaction.sender instanceof Uint8Array ? transaction.sender : new Uint8Array(transaction.sender),
-            recipient: transaction.recipient,
-            nonce: transaction.nonce,
-            timestamp_nanos: transaction.timestamp_nanos,
-            claim: transaction.claim
-          },
-          signature: new Uint8Array(signatureArray)
-        };
-        const response = await fetch(this.proxyUrl, {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify(
-            { jsonrpc: "2.0", method: "set_proxy_submitTransaction", params: submitTxReq, id: 1 },
-            (k, v) => v instanceof Uint8Array ? Array.from(v) : v
-          )
-        });
-        if (!response.ok) throw new Error(`HTTP error! status: ${response.status}`);
-        const jsonResponse = await response.json();
-        if (jsonResponse.error) throw new Error(`JSON-RPC error ${jsonResponse.error.code}: ${jsonResponse.error.message}`);
-        return jsonResponse.result;
-      }
-      async faucetDrip(recipient, amount) {
-        const recipientArray = Array.isArray(recipient) ? recipient : Array.from(recipient);
-        return this.makeRequest("set_proxy_faucetDrip", { recipient: recipientArray, amount });
-      }
-      addressToBytes(address) {
-        try {
-          const decoded = bech32.bech32m.decode(address);
-          return Array.from(bech32.bech32m.fromWords(decoded.words));
-        } catch {
-          const decoded = bech32.bech32.decode(address);
-          return Array.from(bech32.bech32.fromWords(decoded.words));
-        }
-      }
-      // Wallet utilities
-      generateNewWallet() {
-        const privateKey = ed.utils.randomPrivateKey();
-        return new Wallet(Buffer.from(privateKey).toString("hex"));
-      }
-      createWallet(privateKeyHex) {
-        return new Wallet(privateKeyHex);
-      }
-      static decodeBech32Address(address) {
-        try {
-          const decoded = bech32.bech32m.decode(address);
-          return new Uint8Array(bech32.bech32m.fromWords(decoded.words));
-        } catch {
-          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);
-      }
-    };
-    Wallet = class {
-      constructor(privateKeyHex) {
-        this.privateKey = new Uint8Array(Buffer.from(privateKeyHex.replace(/^0x/, ""), "hex"));
-        this.publicKey = ed.getPublicKey(this.privateKey);
-      }
-      toBech32() {
-        return bech32.bech32m.encode("set", bech32.bech32m.toWords(this.publicKey));
-      }
-      signTransactionRaw(data) {
-        return ed.sign(data, this.privateKey);
-      }
-      getPrivateKey() {
-        return this.privateKey;
-      }
-    };
-  }
-});
-
-// src/sdk/index.ts
-var sdk_exports = {};
-__export(sdk_exports, {
-  FastsetClient: () => FastsetClient,
-  Transaction: () => Transaction,
-  Wallet: () => Wallet
-});
-var init_sdk = __esm({
-  "src/sdk/index.ts"() {
-    "use strict";
-    init_FastsetClient();
-  }
-});
-
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  FastsetClient: () => FastsetClient,
   NativeTokenSet: () => NativeTokenSet,
-  Transaction: () => Transaction,
-  Wallet: () => Wallet,
   WarpFastsetExecutor: () => WarpFastsetExecutor,
   WarpFastsetWallet: () => WarpFastsetWallet,
   getFastsetAdapter: () => getFastsetAdapter
@@ -217,19 +49,112 @@ var decoder = new TextDecoder();
 function uint8ArrayToHex(uint8Array) {
   return Buffer.from(uint8Array).toString("hex");
 }
-function hexToUint8Array(hex) {
-  return new Uint8Array(Buffer.from(hex, "hex"));
-}
 function stringToUint8Array(str) {
   return new Uint8Array(Buffer.from(str, "utf8"));
 }
 
 // src/helpers/general.ts
 var import_warps = require("@vleap/warps");
-init_sdk();
+
+// src/sdk/FastsetClient.ts
+var import_bcs = require("@mysten/bcs");
+var bech32 = __toESM(require("bech32"), 1);
+BigInt.prototype.toJSON = function() {
+  return Number(this);
+};
+var bcs = new import_bcs.BCS((0, import_bcs.getSuiMoveConfig)());
+bcs.registerStructType("FastSetAddress", {
+  bytes: "vector<u8>"
+});
+bcs.registerStructType("ExternalAddress", {
+  bytes: "vector<u8>"
+});
+bcs.registerEnumType("Address", {
+  FastSet: "FastSetAddress",
+  External: "ExternalAddress"
+});
+bcs.registerEnumType("UserDataOption", {
+  Some: "vector<u8>",
+  None: "bool"
+  // Use bool for None variant (false = None)
+});
+bcs.registerStructType("TransferClaim", {
+  amount: "u256",
+  // 256-bit unsigned integer
+  user_data: "UserDataOption"
+  // Use our custom option type
+});
+bcs.registerStructType("ClaimType", {
+  Transfer: "TransferClaim"
+});
+bcs.registerStructType("Transaction", {
+  sender: "vector<u8>",
+  // 32 bytes
+  recipient: "Address",
+  nonce: "u64",
+  timestamp_nanos: "u128",
+  claim: "ClaimType"
+});
+var id = 0;
+var FastsetClient = class {
+  constructor(proxyUrl) {
+    this.proxyUrl = proxyUrl;
+  }
+  async request(url, method, params) {
+    const request = this.buildJsonRpcRequest(id++, method, params);
+    const headers = { "Content-Type": "application/json" };
+    const body = this.jsonSerialize(request);
+    const response = await fetch(url, { method: "POST", headers, body });
+    const json = await response.json();
+    return json;
+  }
+  buildJsonRpcRequest(id2, method, params) {
+    return { jsonrpc: "2.0", id: id2, method, params };
+  }
+  jsonSerialize(data) {
+    return JSON.stringify(data, (k, v) => {
+      if (v instanceof Uint8Array) {
+        return Array.from(v);
+      }
+      return v;
+    });
+  }
+  async getAccountInfo(address) {
+    return this.request(this.proxyUrl, "set_proxy_getAccountInfo", { address });
+  }
+  async getNextNonce(address) {
+    const addressBytes = typeof address === "string" ? this.addressToBytes(address) : address;
+    const accountInfoRes = await this.getAccountInfo(addressBytes);
+    return accountInfoRes.result?.next_nonce ?? 0;
+  }
+  addressToBytes(address) {
+    try {
+      const decoded = bech32.bech32m.decode(address);
+      return Array.from(bech32.bech32m.fromWords(decoded.words));
+    } catch {
+      const decoded = bech32.bech32.decode(address);
+      return Array.from(bech32.bech32.fromWords(decoded.words));
+    }
+  }
+  static decodeBech32Address(address) {
+    try {
+      const decoded = bech32.bech32m.decode(address);
+      return new Uint8Array(bech32.bech32m.fromWords(decoded.words));
+    } catch {
+      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);
+  }
+};
+
+// src/helpers/general.ts
 var getConfiguredFastsetClient = (config, chain) => {
   const proxyUrl = (0, import_warps.getProviderUrl)(config, chain.name, config.env, chain.defaultApiUrl);
-  return new FastsetClient({ proxyUrl });
+  return new FastsetClient(proxyUrl);
 };
 
 // src/WarpFastsetDataLoader.ts
@@ -242,17 +167,18 @@ var WarpFastsetDataLoader = class {
   async getAccount(address) {
     const addressBytes = this.addressToBytes(address);
     const accountInfo = await this.client.getAccountInfo(addressBytes);
-    return { chain: this.chain.name, address, balance: BigInt(parseInt(accountInfo.balance, 16)) };
+    return { chain: this.chain.name, address, balance: BigInt(parseInt(accountInfo.result?.balance ?? "0", 16)) };
   }
   async getAccountAssets(address) {
     const addressBytes = this.addressToBytes(address);
     const accountInfo = await this.client.getAccountInfo(addressBytes);
     const assets = [];
-    const balance = BigInt(parseInt(accountInfo.balance, 16));
+    console.log("accountInfo", accountInfo);
+    const balance = BigInt(parseInt(accountInfo.result?.balance ?? "0", 16));
     if (balance > 0n) {
       assets.push({ ...this.chain.nativeToken, amount: balance });
     }
-    for (const [tokenId, tokenBalance] of accountInfo.token_balance) {
+    for (const [tokenId, tokenBalance] of accountInfo.result?.token_balance ?? []) {
       const amount = BigInt(parseInt(tokenBalance, 16));
       if (amount > 0n) {
         const tokenInfo = await this.client.getTokenInfo([tokenId]);
@@ -311,12 +237,11 @@ var WarpFastsetDataLoader = class {
 
 // src/WarpFastsetExecutor.ts
 var import_warps2 = require("@vleap/warps");
-init_sdk();
 var WarpFastsetExecutor = class {
   constructor(config, chain) {
     this.config = config;
     this.chain = chain;
-    this.fastsetClient = new FastsetClient({ proxyUrl: "https://proxy.fastset.xyz" });
+    this.client = getConfiguredFastsetClient(this.config, this.chain);
   }
   async createTransaction(executable) {
     const action = (0, import_warps2.getWarpActionByIndex)(executable.warp, executable.action);
@@ -325,99 +250,30 @@ var WarpFastsetExecutor = class {
     if (action.type === "query") throw new Error("WarpFastsetExecutor: Invalid action type for createTransaction; Use executeQuery instead");
     if (action.type === "collect")
       throw new Error("WarpFastsetExecutor: Invalid action type for createTransaction; Use executeCollect instead");
-    throw new Error(`WarpFastsetExecutor: Invalid action type (unknown)`);
+    throw new Error(`WarpFastsetExecutor: Invalid action type (${action.type})`);
   }
   async createTransferTransaction(executable) {
     const userWallet = (0, import_warps2.getWarpWalletAddressFromConfig)(this.config, executable.chain.name);
     if (!userWallet) throw new Error("WarpFastsetExecutor: createTransfer - user address not set");
-    const senderAddress = FastsetClient.decodeBech32Address(userWallet);
-    let recipientAddress;
-    try {
-      recipientAddress = FastsetClient.decodeBech32Address(executable.destination);
-    } catch (error) {
-      throw new Error(`WarpFastsetExecutor: Invalid destination address: ${executable.destination}`);
-    }
-    const nonce = await this.fastsetClient.getNextNonce(userWallet);
-    const transferValue = executable.transfers?.[0]?.amount || executable.value;
-    if (transferValue < 0) throw new Error(`WarpFastsetExecutor: Transfer value cannot be negative: ${transferValue}`);
-    const amount = "0x" + transferValue.toString(16);
-    const userData = executable.data ? this.fromBase64(executable.data) : null;
-    const claim = { Transfer: { amount, user_data: userData } };
-    return new Transaction(senderAddress, { FastSet: recipientAddress }, nonce, claim);
-  }
-  async createContractCallTransaction(executable) {
-    const userWallet = this.config.user?.wallets?.[executable.chain.name];
-    if (!userWallet) throw new Error("WarpFastsetExecutor: createTransfer - 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");
-    let contractAddress;
-    try {
-      contractAddress = this.fromBase64(executable.destination);
-    } catch (error) {
-      throw new Error(`WarpFastsetExecutor: Invalid contract address: ${executable.destination}`);
-    }
+    const senderPubKey = FastsetClient.decodeBech32Address(userWallet);
+    const recipientPubKey = FastsetClient.decodeBech32Address(executable.destination);
+    const nonce = await this.client.getNextNonce(userWallet);
+    const nativeAmountInTransfers = executable.transfers.find((transfer) => transfer.identifier === this.chain.nativeToken?.identifier)?.amount || 0n;
+    const nativeAmountTotal = nativeAmountInTransfers + executable.value;
+    const amountHex = BigInt(nativeAmountTotal).toString(16);
     return {
-      type: "fastset-contract-call",
-      contract: contractAddress,
-      function: action.func,
-      data: JSON.stringify({ function: action.func, arguments: executable.args }),
-      value: executable.value,
-      chain: executable.chain
-    };
-  }
-  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");
-    try {
-      const result = await this.executeFastsetQuery(this.fromBase64(executable.destination), 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 executeTransfer(executable) {
-    const transaction = await this.createTransferTransaction(executable);
-    return { success: true, transaction, chain: executable.chain.name };
-  }
-  async executeTransferWithKey(executable, privateKey) {
-    const transaction = await this.createTransferTransaction(executable);
-    const privateKeyBytes = this.fromBase64(privateKey);
-    const transactionData = {
-      sender: privateKeyBytes.slice(0, 32),
-      recipient: transaction.getRecipientAddress(),
-      nonce: await this.fastsetClient.getNextNonce(FastsetClient.encodeBech32Address(privateKeyBytes.slice(0, 32))),
+      sender: senderPubKey,
+      recipient: { FastSet: recipientPubKey },
+      nonce,
       timestamp_nanos: BigInt(Date.now()) * 1000000n,
-      claim: { Transfer: { amount: transaction.getAmount(), user_data: transaction.getUserData() } }
+      claim: { Transfer: { amount: amountHex, user_data: null } }
     };
-    const signature = await this.signTransaction(transactionData, privateKeyBytes);
-    const result = await this.fastsetClient.submitTransaction(transactionData, signature);
-    return { success: true, result, message: "Transaction submitted successfully", chain: executable.chain.name };
-  }
-  async signTransaction(transaction, privateKey) {
-    const wallet = new (await Promise.resolve().then(() => (init_sdk(), sdk_exports))).Wallet(Buffer.from(privateKey).toString("hex"));
-    return wallet.signTransactionRaw(this.serializeTransaction(transaction));
-  }
-  serializeTransaction(tx) {
-    const serialized = JSON.stringify(tx, (k, v) => v instanceof Uint8Array ? Array.from(v) : v);
-    return new TextEncoder().encode(serialized);
-  }
-  async executeFastsetQuery(contractAddress, functionName, args) {
-    const response = await fetch("https://proxy.fastset.xyz", {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        jsonrpc: "2.0",
-        method: "set_proxy_query",
-        params: { contract: Array.from(contractAddress), function: functionName, arguments: args },
-        id: 1
-      })
-    });
-    if (!response.ok) throw new Error(`Fastset query failed: ${response.statusText}`);
-    return response.json();
   }
-  fromBase64(base64) {
-    return Uint8Array.from(atob(base64), (c) => c.charCodeAt(0));
+  async createContractCallTransaction(executable) {
+    throw new Error("WarpFastsetExecutor: Not implemented");
+  }
+  async executeQuery(executable) {
+    throw new Error("WarpFastsetExecutor: Not implemented");
   }
 };
 
@@ -643,68 +499,169 @@ var WarpFastsetResults = class {
 // src/WarpFastsetWallet.ts
 var bip39 = __toESM(require("@scure/bip39"), 1);
 var import_warps5 = require("@vleap/warps");
-init_sdk();
-init_ed25519_setup();
+
+// 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/types.ts
+var import_bcs2 = require("@mysten/bcs");
+BigInt.prototype.toJSON = function() {
+  return Number(this);
+};
+var Bytes32 = import_bcs2.bcs.fixedArray(32, import_bcs2.bcs.u8());
+var Bytes64 = import_bcs2.bcs.fixedArray(64, import_bcs2.bcs.u8());
+var PublicKey = Bytes32;
+var Signature = Bytes64;
+var Address = import_bcs2.bcs.enum("Address", {
+  External: PublicKey,
+  FastSet: PublicKey
+});
+var Amount = import_bcs2.bcs.u256().transform({
+  // CAUTION: When we build a transaction object, we must use a hex encoded string because the
+  // validator expects amounts to be in hex. However, bcs.u256() by default expects a decimal
+  // string. Therefore, we must transform the input amount from hex to decimal here.
+  input: (val) => hexToDecimal(val.toString()),
+  output: (value) => value
+});
+var Balance = import_bcs2.bcs.string().transform({
+  input: (val) => val,
+  output: (value) => value
+});
+var UserData = import_bcs2.bcs.option(Bytes32);
+var Nonce = import_bcs2.bcs.u64();
+var Quorum = import_bcs2.bcs.u64();
+var TokenId = Bytes32;
+var Transfer = import_bcs2.bcs.struct("Transfer", {
+  amount: Amount,
+  user_data: UserData
+});
+var TokenTransfer = import_bcs2.bcs.struct("TokenTransfer", {
+  token_id: TokenId,
+  amount: Amount,
+  user_data: UserData
+});
+var TokenCreation = import_bcs2.bcs.struct("TokenCreation", {
+  token_name: import_bcs2.bcs.string(),
+  decimals: import_bcs2.bcs.u8(),
+  initial_amount: Amount,
+  mints: import_bcs2.bcs.vector(PublicKey),
+  user_data: UserData
+});
+var AddressChange = import_bcs2.bcs.enum("AddressChange", {
+  Add: PublicKey,
+  Remove: PublicKey
+});
+var TokenManagement = import_bcs2.bcs.struct("TokenManagement", {
+  token_id: TokenId,
+  update_id: Nonce,
+  new_admin: import_bcs2.bcs.option(PublicKey),
+  mints: import_bcs2.bcs.vector(import_bcs2.bcs.tuple([AddressChange, PublicKey])),
+  user_data: UserData
+});
+var Mint = import_bcs2.bcs.struct("Mint", {
+  token_id: TokenId,
+  amount: Amount
+});
+var ClaimData = import_bcs2.bcs.vector(import_bcs2.bcs.u8());
+var ExternalClaimBody = import_bcs2.bcs.struct("ExternalClaimBody", {
+  verifier_committee: import_bcs2.bcs.vector(PublicKey),
+  verifier_quorum: Quorum,
+  claim_data: ClaimData
+});
+var ExternalClaim = import_bcs2.bcs.struct("ExternalClaim", {
+  claim: ExternalClaimBody,
+  signatures: import_bcs2.bcs.vector(import_bcs2.bcs.tuple([PublicKey, Signature]))
+});
+var ClaimType = import_bcs2.bcs.enum("ClaimType", {
+  Transfer,
+  TokenTransfer,
+  TokenCreation,
+  TokenManagement,
+  Mint,
+  ExternalClaim
+});
+var Transaction = import_bcs2.bcs.struct("Transaction", {
+  sender: PublicKey,
+  recipient: Address,
+  nonce: Nonce,
+  timestamp_nanos: import_bcs2.bcs.u128(),
+  claim: ClaimType
+});
+var SubmitTransactionResponse = import_bcs2.bcs.struct("SubmitTransactionResponse", {
+  validator: PublicKey,
+  signature: Signature,
+  next_nonce: Nonce,
+  transaction_hash: import_bcs2.bcs.vector(import_bcs2.bcs.u8())
+});
+var TransactionEnvelope = import_bcs2.bcs.struct("TransactionEnvelope", {
+  transaction: Transaction,
+  signature: Signature
+});
+var TransactionCertificate = import_bcs2.bcs.struct("TransactionCertificate", {
+  envelope: TransactionEnvelope,
+  signatures: import_bcs2.bcs.vector(import_bcs2.bcs.tuple([PublicKey, Signature]))
+});
+function hexToDecimal(hex) {
+  return BigInt(`0x${hex}`).toString();
+}
+
+// src/WarpFastsetWallet.ts
 var WarpFastsetWallet = class {
   constructor(config, chain) {
     this.config = config;
     this.chain = chain;
-    this.wallet = null;
-    const privateKey = (0, import_warps5.getWarpWalletPrivateKeyFromConfig)(this.config, this.chain.name);
-    if (privateKey) {
-      this.wallet = new Wallet(privateKey);
-    }
     this.client = getConfiguredFastsetClient(this.config, this.chain);
+    const privateKey = (0, import_warps5.getWarpWalletPrivateKeyFromConfig)(this.config, this.chain.name);
+    if (!privateKey) throw new Error("Wallet not initialized - no private key provided");
+    this.privateKey = privateKey;
   }
   async signTransaction(tx) {
-    if (!this.wallet) throw new Error("Wallet not initialized");
-    const transaction = tx;
-    const serializedTx = this.serializeTransaction(transaction.toTransaction());
-    const signature = await ed.sign(serializedTx, this.wallet.getPrivateKey());
-    return Object.assign(transaction, { signature: uint8ArrayToHex(signature) });
+    const msg = Transaction.serialize(tx);
+    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);
+    const signature = ed.sign(dataToSign, this.privateKey);
+    return { ...tx, signature };
   }
   async signMessage(message) {
-    if (!this.wallet) throw new Error("Wallet not initialized");
     const messageBytes = stringToUint8Array(message);
-    const signature = await ed.sign(messageBytes, this.wallet.getPrivateKey());
+    const signature = ed.sign(messageBytes, this.privateKey);
     return uint8ArrayToHex(signature);
   }
   async sendTransaction(tx) {
-    if (!this.wallet) throw new Error("Wallet not initialized");
-    const transaction = tx;
-    const fastsetTx = transaction.toTransaction();
-    const transactionData = {
-      sender: fastsetTx.sender,
-      recipient: fastsetTx.recipient,
-      nonce: fastsetTx.nonce,
-      timestamp_nanos: fastsetTx.timestamp_nanos,
-      claim: fastsetTx.claim
+    const { signature, ...transactionWithoutSignature } = tx;
+    const submitTxReq = {
+      transaction: transactionWithoutSignature,
+      signature
     };
-    const signature = tx.signature ? hexToUint8Array(tx.signature) : await ed.sign(this.serializeTransaction(transactionData), this.wallet.getPrivateKey());
-    return await this.client.submitTransaction(transactionData, signature);
+    const proxyUrl = (0, import_warps5.getProviderUrl)(this.config, this.chain.name, this.config.env, this.chain.defaultApiUrl);
+    const response = await this.client.request(proxyUrl, "set_proxy_submitTransaction", submitTxReq);
+    if (response.error) throw new Error(`JSON-RPC error ${response.error.code}: ${response.error.message}`);
+    console.log("submitTransaction response", response.result);
+    return "TODO";
   }
   create(mnemonic) {
     const seed = bip39.mnemonicToSeedSync(mnemonic);
     const privateKey = seed.slice(0, 32);
-    const wallet = new Wallet(uint8ArrayToHex(privateKey));
-    return { address: wallet.toBech32(), privateKey: uint8ArrayToHex(wallet.getPrivateKey()), mnemonic };
+    const publicKey = ed.getPublicKey(privateKey);
+    const address = FastsetClient.encodeBech32Address(publicKey);
+    return { address, privateKey: uint8ArrayToHex(privateKey), mnemonic };
   }
   generate() {
     const privateKey = ed.utils.randomPrivateKey();
-    const wallet = new Wallet(uint8ArrayToHex(privateKey));
-    return { address: wallet.toBech32(), privateKey: uint8ArrayToHex(wallet.getPrivateKey()), mnemonic: null };
+    const publicKey = ed.getPublicKey(privateKey);
+    const address = FastsetClient.encodeBech32Address(publicKey);
+    return { address, privateKey: uint8ArrayToHex(privateKey), mnemonic: null };
   }
   getAddress() {
     return (0, import_warps5.getWarpWalletAddressFromConfig)(this.config, this.chain.name);
   }
-  serializeTransaction(tx) {
-    const serialized = JSON.stringify(tx, (k, v) => {
-      if (v instanceof Uint8Array) return Array.from(v);
-      if (typeof v === "bigint") return v.toString();
-      return v;
-    });
-    return encoder.encode(serialized);
-  }
 };
 
 // src/main.ts
@@ -713,7 +670,7 @@ var NativeTokenSet = {
   identifier: "SET",
   name: "SET",
   symbol: "SET",
-  decimals: 6,
+  decimals: 0,
   logoUrl: "https://vleap.ai/images/tokens/set.svg"
 };
 function createFastsetAdapter(chainName, chainPrefix, chainInfos) {
@@ -770,15 +727,9 @@ var getFastsetAdapter = createFastsetAdapter(import_warps6.WarpChainName.Fastset
     nativeToken: NativeTokenSet
   }
 });
-
-// src/index.ts
-init_sdk();
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  FastsetClient,
   NativeTokenSet,
-  Transaction,
-  Wallet,
   WarpFastsetExecutor,
   WarpFastsetWallet,
   getFastsetAdapter