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

package/dist/index.d.ts

@@ -1,39 +1,9 @@
-import { AdapterFactory, AdapterWarpExecutor, WarpClientConfig, WarpChainInfo, WarpExecutable, WarpActionInputType, AdapterWarpExplorer, AdapterWarpResults, Warp, WarpExecution, ResolvedInput, WarpExecutionResults, AdapterWarpSerializer, WarpSerializer, WarpNativeValue, BaseWarpActionInputType, WarpAdapterGenericType } from '@vleap/warps';
+import { WarpChainAsset, AdapterFactory, AdapterWarpDataLoader, WarpClientConfig, WarpChainInfo, WarpChainAccount, WarpDataLoaderOptions, WarpChainAction, AdapterWarpExecutor, WarpExecutable, WarpActionInputType, AdapterWarpExplorer, AdapterWarpResults, Warp, WarpExecution, ResolvedInput, WarpExecutionResults, AdapterWarpSerializer, WarpSerializer, WarpNativeValue, BaseWarpActionInputType, WarpAdapterGenericType } from '@vleap/warps';
 import * as _mysten_bcs from '@mysten/bcs';
 
-declare const WarpFastsetConstants: {
-    Pi: {
-        Identifier: string;
-        DisplayName: string;
-        Decimals: number;
-    };
-    GasLimit: {
-        Default: number;
-        ContractCall: number;
-        ContractDeploy: number;
-        Transfer: number;
-        Approve: number;
-        Swap: number;
-    };
-    GasPrice: {
-        Default: string;
-        Low: string;
-        Medium: string;
-        High: string;
-    };
-    Validation: {
-        AddressLength: number;
-        HexPrefix: string;
-        MinGasLimit: number;
-        MaxGasLimit: number;
-    };
-    Timeouts: {
-        DefaultRpcTimeout: number;
-        GasEstimationTimeout: number;
-        QueryTimeout: number;
-    };
-};
+declare const WarpFastsetConstants: {};
 
+declare const NativeTokenSet: WarpChainAsset;
 declare const getFastsetAdapter: AdapterFactory;
 
 declare const Bytes32: _mysten_bcs.BcsType<number[], Iterable<number> & {
@@ -110,7 +80,7 @@ declare const ClaimType: _mysten_bcs.BcsType<{
         }) | null | undefined;
     };
 }>;
-declare const Transaction: _mysten_bcs.BcsType<{
+declare const BcsTransaction: _mysten_bcs.BcsType<{
     sender: number[];
     nonce: string;
     timestamp_nanos: string;
@@ -213,6 +183,30 @@ interface FastsetJsonRpcResponse<T = unknown> {
     };
 }
 
+interface ClaimData {
+    [key: string]: unknown;
+}
+declare abstract class Claim {
+    abstract readonly type: string;
+    abstract readonly data: ClaimData;
+    abstract toTransactionData(): unknown;
+    static fromTransaction(transaction: FastsetTransaction): Claim;
+}
+declare class TransferClaim extends Claim {
+    readonly type = "Transfer";
+    readonly data: {
+        recipient: Uint8Array;
+        amount: string;
+        userData?: Uint8Array;
+    };
+    constructor(recipient: Uint8Array, amount: string, userData?: Uint8Array);
+    toTransactionData(): unknown;
+    static fromData(data: any): TransferClaim;
+    getRecipient(): Uint8Array;
+    getAmount(): string;
+    getUserData(): Uint8Array | undefined;
+}
+
 interface FastsetClientConfig {
     validatorUrl: string;
     proxyUrl: string;
@@ -220,30 +214,93 @@ interface FastsetClientConfig {
 declare class FastsetClient {
     private config;
     constructor(config: FastsetClientConfig);
-    getAccountInfo(address: Uint8Array): Promise<FastsetAccountInfo | null>;
-    getNextNonce(senderAddress: Uint8Array): Promise<number>;
-    fundFromFaucet(request: FastsetFaucetRequest): Promise<FastsetFaucetResponse>;
+    getAccountInfo(address: string): Promise<FastsetAccountInfo | null>;
+    getNextNonce(senderAddress: string): Promise<number>;
+    fundFromFaucet(recipientAddress: string, amount: string): Promise<FastsetFaucetResponse>;
     submitTransaction(request: FastsetSubmitTransactionRequest): Promise<FastsetSubmitTransactionResponse>;
     submitCertificate(request: FastsetSubmitCertificateRequest): Promise<void>;
-    executeTransfer(senderPrivateKey: Uint8Array, recipient: Uint8Array, amount: string, userData?: Uint8Array): Promise<Uint8Array>;
+    executeTransfer(senderPrivateKey: Uint8Array, recipient: string, amount: string, userData?: Uint8Array): Promise<Uint8Array>;
+    submitClaim(senderPrivateKey: Uint8Array, claim: any): Promise<Uint8Array>;
     signTransaction(transaction: FastsetTransaction, privateKey: Uint8Array): Promise<Uint8Array>;
-    private serializeTransaction;
+    getTransactionStatus(txHash: string): Promise<any>;
+    getTransactionInfo(txHash: string): Promise<any>;
+    getNetworkInfo(): Promise<any>;
     private requestValidator;
     private requestProxy;
     private request;
     private jsonReplacer;
 }
 
-declare function isValidFastsetAddress(address: string): boolean;
-declare function fromBase64(base64: string): Uint8Array;
-declare function toBase64String(bytes: Uint8Array): string;
-declare function toHexString(bytes: Uint8Array): string;
-declare function hexToDecimal(hex: string): string;
-declare function decimalToHex(decimal: string): string;
-declare function validateAmount(amount: string): boolean;
-declare function normalizeAmount(amount: string): string;
-declare function validatePrivateKey(privateKey: string | Uint8Array): boolean;
-declare function validatePublicKey(publicKey: string | Uint8Array): boolean;
+interface TransactionOptions {
+    timestamp?: bigint;
+}
+declare class Transaction {
+    private sender;
+    private nonce;
+    private claim;
+    private timestamp;
+    constructor(sender: Uint8Array, nonce: number, claim: Claim, options?: TransactionOptions);
+    toTransaction(): FastsetTransaction;
+    getSender(): Uint8Array;
+    getNonce(): number;
+    getClaim(): Claim;
+    getTimestamp(): bigint;
+    static fromTransaction(transaction: FastsetTransaction): Transaction;
+}
+
+interface WalletConfig {
+    privateKeyHex: string;
+}
+interface WalletInfo {
+    publicKeyHex: string;
+    address: string;
+}
+declare class Wallet {
+    readonly publicKey: Uint8Array;
+    readonly publicKeyHex: string;
+    private readonly privateKey;
+    constructor(privateKeyHex: string);
+    toBech32(): string;
+    getWalletInfo(): WalletInfo;
+    createTransferClaim(recipientAddress: string, amount: bigint, assetType: 'native' | 'set' | 'usdc' | string): TransferClaim;
+    createTransaction(nonce: number, claim: TransferClaim): Transaction;
+    signTransaction(transaction: Transaction): Promise<Uint8Array>;
+    static decodeBech32Address(address: string): Uint8Array;
+    static encodeBech32Address(publicKey: Uint8Array): string;
+    static fromPrivateKey(privateKeyHex: string): Wallet;
+    static generateNew(): Wallet;
+    static fromPrivateKeyFile(filePath: string): Promise<Wallet>;
+}
+
+interface FastsetAccountData {
+    address: string;
+    balance: string;
+    balanceDecimal: number;
+    nextNonce: number;
+    sequenceNumber: number;
+}
+interface FastsetTransactionData {
+    hash: string;
+    hashHex: string;
+    status: string;
+    details: any;
+}
+declare class WarpFastsetDataLoader implements AdapterWarpDataLoader {
+    private readonly config;
+    private readonly chain;
+    private client;
+    constructor(config: WarpClientConfig, chain: WarpChainInfo);
+    getAccount(address: string): Promise<WarpChainAccount>;
+    getAccountAssets(address: string): Promise<WarpChainAsset[]>;
+    getAccountActions(address: string, options?: WarpDataLoaderOptions): Promise<WarpChainAction[]>;
+    getAccountInfo(address: string): Promise<FastsetAccountData | null>;
+    getTransactionInfo(txHash: string): Promise<FastsetTransactionData | null>;
+    checkTransferStatus(fromAddress: string, toAddress: string, amount: string): Promise<boolean>;
+    getAccountBalance(address: string): Promise<{
+        balance: string;
+        balanceDecimal: number;
+    } | null>;
+}
 
 declare class WarpFastsetExecutor implements AdapterWarpExecutor {
     private readonly config;
@@ -256,39 +313,41 @@ declare class WarpFastsetExecutor implements AdapterWarpExecutor {
     createContractCallTransaction(executable: WarpExecutable): Promise<any>;
     executeQuery(executable: WarpExecutable): Promise<any>;
     preprocessInput(chain: WarpChainInfo, input: string, type: WarpActionInputType, value: string): Promise<string>;
-    private encodeFunctionData;
-    private executeFastsetQuery;
     signMessage(message: string, privateKey: string): Promise<string>;
     executeTransfer(executable: WarpExecutable): Promise<any>;
     executeTransferWithKey(executable: WarpExecutable, privateKey: string): Promise<any>;
+    private encodeFunctionData;
+    private executeFastsetQuery;
+    private isValidFastsetAddress;
+    private fromBase64;
+    private normalizeAmount;
 }
 
 declare class WarpFastsetExplorer implements AdapterWarpExplorer {
-    private readonly chainInfo;
-    constructor(chainInfo: WarpChainInfo);
+    private readonly _chainInfo;
+    private readonly _config?;
+    private readonly explorerUrl;
+    constructor(_chainInfo: WarpChainInfo, _config?: WarpClientConfig | undefined);
     getAccountUrl(address: string): string;
     getTransactionUrl(hash: string): string;
-    getBlockUrl(blockNumber: string | number): string;
-    getContractUrl(address: string): string;
     getAssetUrl(identifier: string): string;
-    private getDefaultExplorerUrl;
+    getContractUrl(address: string): string;
 }
 
 declare class WarpFastsetResults implements AdapterWarpResults {
     private readonly config;
+    private readonly chain;
     private readonly serializer;
-    constructor(config: WarpClientConfig);
+    constructor(config: WarpClientConfig, chain: WarpChainInfo);
     getTransactionExecutionResults(warp: Warp, tx: any): Promise<WarpExecution>;
     extractQueryResults(warp: Warp, typedValues: any[], actionIndex: number, inputs: ResolvedInput[]): Promise<{
         values: any[];
         results: WarpExecutionResults;
     }>;
     private isTransactionSuccessful;
-    private extractGasUsed;
-    private extractGasPrice;
-    private extractBlockNumber;
     private extractTransactionHash;
-    private extractLogs;
+    private extractBlockNumber;
+    private extractTimestamp;
 }
 
 declare class WarpFastsetSerializer implements AdapterWarpSerializer {
@@ -301,4 +360,4 @@ declare class WarpFastsetSerializer implements AdapterWarpSerializer {
     stringToTyped(value: string): any;
 }
 
-export { Address, Amount, Bytes32, ClaimType, type FastsetAccountInfo, FastsetClient, type FastsetClientConfig, type FastsetFaucetRequest, type FastsetFaucetResponse, type FastsetJsonRpcRequest, type FastsetJsonRpcResponse, type FastsetSubmitCertificateRequest, type FastsetSubmitTransactionRequest, type FastsetSubmitTransactionResponse, type FastsetTransaction, type FastsetTransferRequest, Nonce, PublicKey, Transaction, Transfer, UserData, WarpFastsetConstants, WarpFastsetExecutor, WarpFastsetExplorer, WarpFastsetResults, WarpFastsetSerializer, decimalToHex, fromBase64, getFastsetAdapter, hexToDecimal, isValidFastsetAddress, normalizeAmount, toBase64String, toHexString, validateAmount, validatePrivateKey, validatePublicKey };
+export { Address, Amount, BcsTransaction, Bytes32, Claim, type ClaimData, ClaimType, type FastsetAccountData, type FastsetAccountInfo, FastsetClient, type FastsetClientConfig, type FastsetFaucetRequest, type FastsetFaucetResponse, type FastsetJsonRpcRequest, type FastsetJsonRpcResponse, type FastsetSubmitCertificateRequest, type FastsetSubmitTransactionRequest, type FastsetSubmitTransactionResponse, type FastsetTransaction, type FastsetTransactionData, type FastsetTransferRequest, NativeTokenSet, Nonce, PublicKey, Transaction, type TransactionOptions, Transfer, TransferClaim, UserData, Wallet, type WalletConfig, type WalletInfo, WarpFastsetConstants, WarpFastsetDataLoader, WarpFastsetExecutor, WarpFastsetExplorer, WarpFastsetResults, WarpFastsetSerializer, getFastsetAdapter };