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

package/dist/index.d.cts

@@ -0,0 +1,363 @@
+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: {};
+
+declare const NativeTokenSet: WarpChainAsset;
+declare const getFastsetAdapter: AdapterFactory;
+
+declare const Bytes32: _mysten_bcs.BcsType<number[], Iterable<number> & {
+    length: number;
+}>;
+declare const PublicKey: _mysten_bcs.BcsType<number[], Iterable<number> & {
+    length: number;
+}>;
+declare const Address: _mysten_bcs.BcsType<{
+    External: number[];
+} | {
+    FastSet: number[];
+}, {
+    External: Iterable<number> & {
+        length: number;
+    };
+} | {
+    FastSet: Iterable<number> & {
+        length: number;
+    };
+}>;
+declare const Amount: _mysten_bcs.BcsType<string, unknown>;
+declare const UserData: _mysten_bcs.BcsType<number[] | null, (Iterable<number> & {
+    length: number;
+}) | null | undefined>;
+declare const Nonce: _mysten_bcs.BcsType<string, string | number | bigint>;
+declare const Transfer: _mysten_bcs.BcsType<{
+    recipient: {
+        External: number[];
+    } | {
+        FastSet: number[];
+    };
+    amount: string;
+    user_data: number[] | null;
+}, {
+    recipient: {
+        External: Iterable<number> & {
+            length: number;
+        };
+    } | {
+        FastSet: Iterable<number> & {
+            length: number;
+        };
+    };
+    amount: unknown;
+    user_data: (Iterable<number> & {
+        length: number;
+    }) | null | undefined;
+}>;
+declare const ClaimType: _mysten_bcs.BcsType<{
+    Transfer: {
+        recipient: {
+            External: number[];
+        } | {
+            FastSet: number[];
+        };
+        amount: string;
+        user_data: number[] | null;
+    };
+}, {
+    Transfer: {
+        recipient: {
+            External: Iterable<number> & {
+                length: number;
+            };
+        } | {
+            FastSet: Iterable<number> & {
+                length: number;
+            };
+        };
+        amount: unknown;
+        user_data: (Iterable<number> & {
+            length: number;
+        }) | null | undefined;
+    };
+}>;
+declare const BcsTransaction: _mysten_bcs.BcsType<{
+    sender: number[];
+    nonce: string;
+    timestamp_nanos: string;
+    claim: {
+        Transfer: {
+            recipient: {
+                External: number[];
+            } | {
+                FastSet: number[];
+            };
+            amount: string;
+            user_data: number[] | null;
+        };
+    };
+}, {
+    sender: Iterable<number> & {
+        length: number;
+    };
+    nonce: string | number | bigint;
+    timestamp_nanos: string | number | bigint;
+    claim: {
+        Transfer: {
+            recipient: {
+                External: Iterable<number> & {
+                    length: number;
+                };
+            } | {
+                FastSet: Iterable<number> & {
+                    length: number;
+                };
+            };
+            amount: unknown;
+            user_data: (Iterable<number> & {
+                length: number;
+            }) | null | undefined;
+        };
+    };
+}>;
+interface FastsetTransaction {
+    sender: Uint8Array;
+    nonce: number;
+    timestamp_nanos: bigint;
+    claim: {
+        Transfer: {
+            recipient: {
+                FastSet: Uint8Array;
+            } | {
+                External: Uint8Array;
+            };
+            amount: string;
+            user_data: Uint8Array | null;
+        };
+    };
+}
+interface FastsetTransferRequest {
+    recipient: Uint8Array;
+    amount: string;
+    user_data?: Uint8Array;
+}
+interface FastsetAccountInfo {
+    balance: string;
+    next_nonce: number;
+    sequence_number: number;
+}
+interface FastsetSubmitTransactionRequest {
+    transaction: FastsetTransaction;
+    signature: Uint8Array;
+}
+interface FastsetSubmitTransactionResponse {
+    transaction_hash: Uint8Array;
+    validator: Uint8Array;
+    signature: Uint8Array;
+}
+interface FastsetSubmitCertificateRequest {
+    transaction: FastsetTransaction;
+    signature: Uint8Array;
+    validator_signatures: [Uint8Array, Uint8Array][];
+}
+interface FastsetFaucetRequest {
+    recipient: Uint8Array;
+    amount: string;
+}
+interface FastsetFaucetResponse {
+    balance: string;
+}
+interface FastsetJsonRpcRequest {
+    jsonrpc: '2.0';
+    id: number;
+    method: string;
+    params: Record<string, unknown>;
+}
+interface FastsetJsonRpcResponse<T = unknown> {
+    jsonrpc: '2.0';
+    id: number;
+    result?: T;
+    error?: {
+        code: number;
+        message: string;
+        data?: 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;
+}
+declare class FastsetClient {
+    private config;
+    constructor(config: FastsetClientConfig);
+    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: string, amount: string, userData?: Uint8Array): Promise<Uint8Array>;
+    submitClaim(senderPrivateKey: Uint8Array, claim: any): Promise<Uint8Array>;
+    signTransaction(transaction: FastsetTransaction, privateKey: Uint8Array): Promise<Uint8Array>;
+    getTransactionStatus(txHash: string): Promise<any>;
+    getTransactionInfo(txHash: string): Promise<any>;
+    getNetworkInfo(): Promise<any>;
+    private requestValidator;
+    private requestProxy;
+    private request;
+    private jsonReplacer;
+}
+
+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;
+    private readonly chain;
+    private readonly serializer;
+    private readonly fastsetClient;
+    constructor(config: WarpClientConfig, chain: WarpChainInfo);
+    createTransaction(executable: WarpExecutable): Promise<any>;
+    createTransferTransaction(executable: WarpExecutable): Promise<any>;
+    createContractCallTransaction(executable: WarpExecutable): Promise<any>;
+    executeQuery(executable: WarpExecutable): Promise<any>;
+    preprocessInput(chain: WarpChainInfo, input: string, type: WarpActionInputType, value: string): Promise<string>;
+    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;
+    private readonly _config?;
+    private readonly explorerUrl;
+    constructor(_chainInfo: WarpChainInfo, _config?: WarpClientConfig | undefined);
+    getAccountUrl(address: string): string;
+    getTransactionUrl(hash: string): string;
+    getAssetUrl(identifier: string): string;
+    getContractUrl(address: string): string;
+}
+
+declare class WarpFastsetResults implements AdapterWarpResults {
+    private readonly config;
+    private readonly chain;
+    private readonly serializer;
+    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 extractTransactionHash;
+    private extractBlockNumber;
+    private extractTimestamp;
+}
+
+declare class WarpFastsetSerializer implements AdapterWarpSerializer {
+    readonly coreSerializer: WarpSerializer;
+    constructor();
+    typedToString(value: any): string;
+    typedToNative(value: any): [WarpActionInputType, WarpNativeValue];
+    nativeToTyped(type: WarpActionInputType, value: WarpNativeValue): any;
+    nativeToType(type: BaseWarpActionInputType): WarpAdapterGenericType;
+    stringToTyped(value: string): any;
+}
+
+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 };