near-api-ts 0.2.0

package/dist/index.d.cts

@@ -0,0 +1,838 @@
+import { RpcBlockResponse, RpcTransactionResponse } from '@near-js/jsonrpc-types';
+import * as z from 'zod/mini';
+
+/**
+ * Binary length: 32 bytes
+ */
+type CryptoHash = string;
+type BlockHash = CryptoHash;
+type BlockHeight = number;
+type BlockId = {
+    blockHash: BlockHash;
+} | {
+    blockHeight: BlockHeight;
+};
+type LatestBlock = 'LatestOptimisticBlock' | 'LatestNearFinalBlock' | 'LatestFinalBlock';
+type SyncCheckpoint = 'EarliestAvailableBlock' | 'GenesisBlock';
+type BlockReference = LatestBlock | SyncCheckpoint | BlockId;
+type Base58String = string;
+type Base64String = string;
+type Nonce = number;
+type AccountId = string;
+/**
+ * Contract function name has limit - max 256 characters
+ */
+type ContractFunctionName = string;
+type YoctoNear = bigint;
+type Near = string;
+type NearToken = Readonly<{
+    yoctoNear: YoctoNear;
+    near: Near;
+    add: (value: NearOption) => NearToken;
+    sub: (value: NearOption) => NearToken;
+    mul: (value: NearOption) => NearToken;
+    gt: (value: NearOption) => NearToken;
+    lt: (value: NearOption) => NearToken;
+}>;
+type Units = bigint | string;
+type Tokens = string;
+type NearOption = {
+    near: Tokens;
+} | {
+    yoctoNear: Units;
+};
+type GasInput = bigint | number;
+type TeraGasInput = string;
+type GasOption = {
+    gas: GasInput;
+} | {
+    teraGas: TeraGasInput;
+};
+type JsonLikeValue = string | number | boolean | null | JsonLikeValue[] | {
+    [key: string]: JsonLikeValue | undefined;
+};
+type MaybeJsonLikeValue = JsonLikeValue | undefined;
+
+type GetAccountStateArgs = {
+    accountId: AccountId;
+    atMomentOf?: BlockReference;
+};
+type GetAccountStateResult = {
+    blockHash: BlockHash;
+    blockHeight: BlockHeight;
+    accountId: AccountId;
+    accountState: {
+        balance: {
+            total: NearToken;
+            locked: NearToken;
+        };
+        usedStorageBytes: number;
+        contractWasmHash: CryptoHash;
+        globalContractAccountId?: AccountId;
+        globalContractHash?: CryptoHash;
+    };
+};
+type GetAccountState = (args: GetAccountStateArgs) => Promise<GetAccountStateResult>;
+
+type Ed25519Curve = 'ed25519';
+type Secp256k1Curve = 'secp256k1';
+type Ed25519CurveString = `${Ed25519Curve}:${Base58String}`;
+type Secp256k1CurveString = `${Secp256k1Curve}:${Base58String}`;
+type CurveString = Ed25519CurveString | Secp256k1CurveString;
+type Ed25519PublicKey = Ed25519CurveString;
+type Secp256k1PublicKey = Secp256k1CurveString;
+type PublicKey = Ed25519PublicKey | Secp256k1PublicKey;
+type PrivateKey = CurveString;
+type Signature = CurveString;
+
+type FullAccessKey = {
+    accessType: 'FullAccess';
+    publicKey: PublicKey;
+    nonce: Nonce;
+};
+type FunctionCallKey = {
+    accessType: 'FunctionCall';
+    publicKey: PublicKey;
+    nonce: Nonce;
+    contractAccountId: AccountId;
+    gasBudget?: NearToken;
+    allowedFunctions?: ContractFunctionName[];
+};
+type AccountKey = FullAccessKey | FunctionCallKey;
+
+type GetAccountKeyArgs = {
+    accountId: AccountId;
+    publicKey: PublicKey;
+    atMomentOf?: BlockReference;
+};
+type GetAccountKeyResult = {
+    blockHash: BlockHash;
+    blockHeight: BlockHeight;
+    accountId: AccountId;
+    accountKey: AccountKey;
+};
+type GetAccountKey = (args: GetAccountKeyArgs) => Promise<GetAccountKeyResult>;
+
+type GetAccountKeysArgs = {
+    accountId: AccountId;
+    atMomentOf?: BlockReference;
+};
+type GetAccountKeysResult = {
+    blockHash: BlockHash;
+    blockHeight: BlockHeight;
+    accountId: AccountId;
+    accountKeys: AccountKey[];
+};
+type GetAccountKeys = (args: GetAccountKeysArgs) => Promise<GetAccountKeysResult>;
+
+type GetBlockArgs = {
+    blockReference?: BlockReference;
+};
+type GetBlockResult = RpcBlockResponse;
+type GetBlock = (args?: GetBlockArgs) => Promise<GetBlockResult>;
+
+type GetGasPriceArgs = {
+    atMomentOf?: 'LatestOptimisticBlock' | BlockId;
+};
+type GetGasPriceResult = {
+    gasPrice: NearToken;
+};
+type GetGasPrice = (args?: GetGasPriceArgs) => Promise<GetGasPriceResult>;
+
+declare const TemporaryProtocolConfigShema: z.ZodMiniObject<{
+    runtimeConfig: z.ZodMiniObject<{
+        wasmConfig: z.ZodMiniObject<{
+            discardCustomSections: z.ZodMiniBoolean<boolean>;
+            ethImplicitAccounts: z.ZodMiniBoolean<boolean>;
+            extCosts: z.ZodMiniLazy<z.ZodMiniObject<{
+                altBn128G1MultiexpBase: z.ZodMiniNumber<number>;
+                altBn128G1MultiexpElement: z.ZodMiniNumber<number>;
+                altBn128G1SumBase: z.ZodMiniNumber<number>;
+                altBn128G1SumElement: z.ZodMiniNumber<number>;
+                altBn128PairingCheckBase: z.ZodMiniNumber<number>;
+                altBn128PairingCheckElement: z.ZodMiniNumber<number>;
+                base: z.ZodMiniNumber<number>;
+                bls12381G1MultiexpBase: z.ZodMiniNumber<number>;
+                bls12381G1MultiexpElement: z.ZodMiniNumber<number>;
+                bls12381G2MultiexpBase: z.ZodMiniNumber<number>;
+                bls12381G2MultiexpElement: z.ZodMiniNumber<number>;
+                bls12381MapFp2ToG2Base: z.ZodMiniNumber<number>;
+                bls12381MapFp2ToG2Element: z.ZodMiniNumber<number>;
+                bls12381MapFpToG1Base: z.ZodMiniNumber<number>;
+                bls12381MapFpToG1Element: z.ZodMiniNumber<number>;
+                bls12381P1DecompressBase: z.ZodMiniNumber<number>;
+                bls12381P1DecompressElement: z.ZodMiniNumber<number>;
+                bls12381P1SumBase: z.ZodMiniNumber<number>;
+                bls12381P1SumElement: z.ZodMiniNumber<number>;
+                bls12381P2DecompressBase: z.ZodMiniNumber<number>;
+                bls12381P2DecompressElement: z.ZodMiniNumber<number>;
+                bls12381P2SumBase: z.ZodMiniNumber<number>;
+                bls12381P2SumElement: z.ZodMiniNumber<number>;
+                bls12381PairingBase: z.ZodMiniNumber<number>;
+                bls12381PairingElement: z.ZodMiniNumber<number>;
+                contractCompileBase: z.ZodMiniNumber<number>;
+                contractCompileBytes: z.ZodMiniNumber<number>;
+                contractLoadingBase: z.ZodMiniNumber<number>;
+                contractLoadingBytes: z.ZodMiniNumber<number>;
+                ecrecoverBase: z.ZodMiniNumber<number>;
+                ed25519VerifyBase: z.ZodMiniNumber<number>;
+                ed25519VerifyByte: z.ZodMiniNumber<number>;
+                keccak256Base: z.ZodMiniNumber<number>;
+                keccak256Byte: z.ZodMiniNumber<number>;
+                keccak512Base: z.ZodMiniNumber<number>;
+                keccak512Byte: z.ZodMiniNumber<number>;
+                logBase: z.ZodMiniNumber<number>;
+                logByte: z.ZodMiniNumber<number>;
+                promiseAndBase: z.ZodMiniNumber<number>;
+                promiseAndPerPromise: z.ZodMiniNumber<number>;
+                promiseReturn: z.ZodMiniNumber<number>;
+                readCachedTrieNode: z.ZodMiniNumber<number>;
+                readMemoryBase: z.ZodMiniNumber<number>;
+                readMemoryByte: z.ZodMiniNumber<number>;
+                readRegisterBase: z.ZodMiniNumber<number>;
+                readRegisterByte: z.ZodMiniNumber<number>;
+                ripemd160Base: z.ZodMiniNumber<number>;
+                ripemd160Block: z.ZodMiniNumber<number>;
+                sha256Base: z.ZodMiniNumber<number>;
+                sha256Byte: z.ZodMiniNumber<number>;
+                storageHasKeyBase: z.ZodMiniNumber<number>;
+                storageHasKeyByte: z.ZodMiniNumber<number>;
+                storageIterCreateFromByte: z.ZodMiniNumber<number>;
+                storageIterCreatePrefixBase: z.ZodMiniNumber<number>;
+                storageIterCreatePrefixByte: z.ZodMiniNumber<number>;
+                storageIterCreateRangeBase: z.ZodMiniNumber<number>;
+                storageIterCreateToByte: z.ZodMiniNumber<number>;
+                storageIterNextBase: z.ZodMiniNumber<number>;
+                storageIterNextKeyByte: z.ZodMiniNumber<number>;
+                storageIterNextValueByte: z.ZodMiniNumber<number>;
+                storageLargeReadOverheadBase: z.ZodMiniNumber<number>;
+                storageLargeReadOverheadByte: z.ZodMiniNumber<number>;
+                storageReadBase: z.ZodMiniNumber<number>;
+                storageReadKeyByte: z.ZodMiniNumber<number>;
+                storageReadValueByte: z.ZodMiniNumber<number>;
+                storageRemoveBase: z.ZodMiniNumber<number>;
+                storageRemoveKeyByte: z.ZodMiniNumber<number>;
+                storageRemoveRetValueByte: z.ZodMiniNumber<number>;
+                storageWriteBase: z.ZodMiniNumber<number>;
+                storageWriteEvictedByte: z.ZodMiniNumber<number>;
+                storageWriteKeyByte: z.ZodMiniNumber<number>;
+                storageWriteValueByte: z.ZodMiniNumber<number>;
+                touchingTrieNode: z.ZodMiniNumber<number>;
+                utf16DecodingBase: z.ZodMiniNumber<number>;
+                utf16DecodingByte: z.ZodMiniNumber<number>;
+                utf8DecodingBase: z.ZodMiniNumber<number>;
+                utf8DecodingByte: z.ZodMiniNumber<number>;
+                validatorStakeBase: z.ZodMiniNumber<number>;
+                validatorTotalStakeBase: z.ZodMiniNumber<number>;
+                writeMemoryBase: z.ZodMiniNumber<number>;
+                writeMemoryByte: z.ZodMiniNumber<number>;
+                writeRegisterBase: z.ZodMiniNumber<number>;
+                writeRegisterByte: z.ZodMiniNumber<number>;
+                yieldCreateBase: z.ZodMiniNumber<number>;
+                yieldCreateByte: z.ZodMiniNumber<number>;
+                yieldResumeBase: z.ZodMiniNumber<number>;
+                yieldResumeByte: z.ZodMiniNumber<number>;
+            }, z.core.$strip>>;
+            fixContractLoadingCost: z.ZodMiniBoolean<boolean>;
+            globalContractHostFns: z.ZodMiniBoolean<boolean>;
+            growMemCost: z.ZodMiniNumber<number>;
+            implicitAccountCreation: z.ZodMiniBoolean<boolean>;
+            limitConfig: z.ZodMiniLazy<z.ZodMiniObject<{
+                accountIdValidityRulesVersion: z.ZodMiniOptional<z.ZodMiniLazy<z.ZodMiniNumber<number>>>;
+                initialMemoryPages: z.ZodMiniNumber<number>;
+                maxActionsPerReceipt: z.ZodMiniNumber<number>;
+                maxArgumentsLength: z.ZodMiniNumber<number>;
+                maxContractSize: z.ZodMiniNumber<number>;
+                maxElementsPerContractTable: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniUnion<readonly [z.ZodMiniNumber<number>, z.ZodMiniNull]>, z.ZodMiniNull]>>;
+                maxFunctionsNumberPerContract: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniUnion<readonly [z.ZodMiniNumber<number>, z.ZodMiniNull]>, z.ZodMiniNull]>>;
+                maxGasBurnt: z.ZodMiniNumber<number>;
+                maxLengthMethodName: z.ZodMiniNumber<number>;
+                maxLengthReturnedData: z.ZodMiniNumber<number>;
+                maxLengthStorageKey: z.ZodMiniNumber<number>;
+                maxLengthStorageValue: z.ZodMiniNumber<number>;
+                maxLocalsPerContract: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniUnion<readonly [z.ZodMiniNumber<number>, z.ZodMiniNull]>, z.ZodMiniNull]>>;
+                maxMemoryPages: z.ZodMiniNumber<number>;
+                maxNumberBytesMethodNames: z.ZodMiniNumber<number>;
+                maxNumberInputDataDependencies: z.ZodMiniNumber<number>;
+                maxNumberLogs: z.ZodMiniNumber<number>;
+                maxNumberRegisters: z.ZodMiniNumber<number>;
+                maxPromisesPerFunctionCallAction: z.ZodMiniNumber<number>;
+                maxReceiptSize: z.ZodMiniNumber<number>;
+                maxRegisterSize: z.ZodMiniNumber<number>;
+                maxStackHeight: z.ZodMiniNumber<number>;
+                maxTablesPerContract: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniUnion<readonly [z.ZodMiniNumber<number>, z.ZodMiniNull]>, z.ZodMiniNull]>>;
+                maxTotalLogLength: z.ZodMiniNumber<number>;
+                maxTotalPrepaidGas: z.ZodMiniNumber<number>;
+                maxTransactionSize: z.ZodMiniNumber<number>;
+                maxYieldPayloadSize: z.ZodMiniNumber<number>;
+                perReceiptStorageProofSizeLimit: z.ZodMiniNumber<number>;
+                registersMemoryLimit: z.ZodMiniNumber<number>;
+                yieldTimeoutLengthInBlocks: z.ZodMiniNumber<number>;
+            }, z.core.$strip>>;
+            regularOpCost: z.ZodMiniNumber<number>;
+            saturatingFloatToInt: z.ZodMiniBoolean<boolean>;
+            storageGetMode: z.ZodMiniLazy<z.ZodMiniEnum<{
+                FlatStorage: "FlatStorage";
+                Trie: "Trie";
+            }>>;
+            vmKind: z.ZodMiniLazy<z.ZodMiniUnion<readonly [z.ZodMiniEnum<{
+                Wasmer0: "Wasmer0";
+            }>, z.ZodMiniEnum<{
+                Wasmtime: "Wasmtime";
+            }>, z.ZodMiniEnum<{
+                Wasmer2: "Wasmer2";
+            }>, z.ZodMiniEnum<{
+                NearVm: "NearVm";
+            }>, z.ZodMiniEnum<{
+                NearVm2: "NearVm2";
+            }>]>>;
+        }, z.core.$strip>;
+        accountCreationConfig: z.ZodMiniLazy<z.ZodMiniObject<{
+            minAllowedTopLevelAccountLength: z.ZodMiniNumber<number>;
+            registrarAccountId: z.ZodMiniLazy<z.ZodMiniString<string>>;
+        }, z.core.$strip>>;
+        congestionControlConfig: z.ZodMiniLazy<z.ZodMiniObject<{
+            allowedShardOutgoingGas: z.ZodMiniNumber<number>;
+            maxCongestionIncomingGas: z.ZodMiniNumber<number>;
+            maxCongestionMemoryConsumption: z.ZodMiniNumber<number>;
+            maxCongestionMissedChunks: z.ZodMiniNumber<number>;
+            maxCongestionOutgoingGas: z.ZodMiniNumber<number>;
+            maxOutgoingGas: z.ZodMiniNumber<number>;
+            maxTxGas: z.ZodMiniNumber<number>;
+            minOutgoingGas: z.ZodMiniNumber<number>;
+            minTxGas: z.ZodMiniNumber<number>;
+            outgoingReceiptsBigSizeLimit: z.ZodMiniNumber<number>;
+            outgoingReceiptsUsualSizeLimit: z.ZodMiniNumber<number>;
+            rejectTxCongestionThreshold: z.ZodMiniNumber<number>;
+        }, z.core.$strip>>;
+        storageAmountPerByte: z.ZodMiniString<string>;
+        transactionCosts: z.ZodMiniLazy<z.ZodMiniObject<{
+            actionCreationConfig: z.ZodMiniLazy<z.ZodMiniObject<{
+                addKeyCost: z.ZodMiniLazy<z.ZodMiniObject<{
+                    fullAccessCost: z.ZodMiniLazy<z.ZodMiniObject<{
+                        execution: z.ZodMiniNumber<number>;
+                        sendNotSir: z.ZodMiniNumber<number>;
+                        sendSir: z.ZodMiniNumber<number>;
+                    }, z.core.$strip>>;
+                    functionCallCost: z.ZodMiniLazy<z.ZodMiniObject<{
+                        execution: z.ZodMiniNumber<number>;
+                        sendNotSir: z.ZodMiniNumber<number>;
+                        sendSir: z.ZodMiniNumber<number>;
+                    }, z.core.$strip>>;
+                    functionCallCostPerByte: z.ZodMiniLazy<z.ZodMiniObject<{
+                        execution: z.ZodMiniNumber<number>;
+                        sendNotSir: z.ZodMiniNumber<number>;
+                        sendSir: z.ZodMiniNumber<number>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>>;
+                createAccountCost: z.ZodMiniLazy<z.ZodMiniObject<{
+                    execution: z.ZodMiniNumber<number>;
+                    sendNotSir: z.ZodMiniNumber<number>;
+                    sendSir: z.ZodMiniNumber<number>;
+                }, z.core.$strip>>;
+                delegateCost: z.ZodMiniLazy<z.ZodMiniObject<{
+                    execution: z.ZodMiniNumber<number>;
+                    sendNotSir: z.ZodMiniNumber<number>;
+                    sendSir: z.ZodMiniNumber<number>;
+                }, z.core.$strip>>;
+                deleteAccountCost: z.ZodMiniLazy<z.ZodMiniObject<{
+                    execution: z.ZodMiniNumber<number>;
+                    sendNotSir: z.ZodMiniNumber<number>;
+                    sendSir: z.ZodMiniNumber<number>;
+                }, z.core.$strip>>;
+                deleteKeyCost: z.ZodMiniLazy<z.ZodMiniObject<{
+                    execution: z.ZodMiniNumber<number>;
+                    sendNotSir: z.ZodMiniNumber<number>;
+                    sendSir: z.ZodMiniNumber<number>;
+                }, z.core.$strip>>;
+                deployContractCost: z.ZodMiniLazy<z.ZodMiniObject<{
+                    execution: z.ZodMiniNumber<number>;
+                    sendNotSir: z.ZodMiniNumber<number>;
+                    sendSir: z.ZodMiniNumber<number>;
+                }, z.core.$strip>>;
+                deployContractCostPerByte: z.ZodMiniLazy<z.ZodMiniObject<{
+                    execution: z.ZodMiniNumber<number>;
+                    sendNotSir: z.ZodMiniNumber<number>;
+                    sendSir: z.ZodMiniNumber<number>;
+                }, z.core.$strip>>;
+                functionCallCost: z.ZodMiniLazy<z.ZodMiniObject<{
+                    execution: z.ZodMiniNumber<number>;
+                    sendNotSir: z.ZodMiniNumber<number>;
+                    sendSir: z.ZodMiniNumber<number>;
+                }, z.core.$strip>>;
+                functionCallCostPerByte: z.ZodMiniLazy<z.ZodMiniObject<{
+                    execution: z.ZodMiniNumber<number>;
+                    sendNotSir: z.ZodMiniNumber<number>;
+                    sendSir: z.ZodMiniNumber<number>;
+                }, z.core.$strip>>;
+                stakeCost: z.ZodMiniLazy<z.ZodMiniObject<{
+                    execution: z.ZodMiniNumber<number>;
+                    sendNotSir: z.ZodMiniNumber<number>;
+                    sendSir: z.ZodMiniNumber<number>;
+                }, z.core.$strip>>;
+                transferCost: z.ZodMiniLazy<z.ZodMiniObject<{
+                    execution: z.ZodMiniNumber<number>;
+                    sendNotSir: z.ZodMiniNumber<number>;
+                    sendSir: z.ZodMiniNumber<number>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            actionReceiptCreationConfig: z.ZodMiniLazy<z.ZodMiniObject<{
+                execution: z.ZodMiniNumber<number>;
+                sendNotSir: z.ZodMiniNumber<number>;
+                sendSir: z.ZodMiniNumber<number>;
+            }, z.core.$strip>>;
+            burntGasReward: z.ZodMiniArray<z.ZodMiniNumber<number>>;
+            dataReceiptCreationConfig: z.ZodMiniLazy<z.ZodMiniObject<{
+                baseCost: z.ZodMiniLazy<z.ZodMiniObject<{
+                    execution: z.ZodMiniNumber<number>;
+                    sendNotSir: z.ZodMiniNumber<number>;
+                    sendSir: z.ZodMiniNumber<number>;
+                }, z.core.$strip>>;
+                costPerByte: z.ZodMiniLazy<z.ZodMiniObject<{
+                    execution: z.ZodMiniNumber<number>;
+                    sendNotSir: z.ZodMiniNumber<number>;
+                    sendSir: z.ZodMiniNumber<number>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            pessimisticGasPriceInflationRatio: z.ZodMiniArray<z.ZodMiniNumber<number>>;
+            storageUsageConfig: z.ZodMiniLazy<z.ZodMiniObject<{
+                numBytesAccount: z.ZodMiniNumber<number>;
+                numExtraBytesRecord: z.ZodMiniNumber<number>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        witnessConfig: z.ZodMiniLazy<z.ZodMiniObject<{
+            combinedTransactionsSizeLimit: z.ZodMiniNumber<number>;
+            mainStorageProofSizeSoftLimit: z.ZodMiniNumber<number>;
+            newTransactionsValidationStateSizeSoftLimit: z.ZodMiniNumber<number>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    avgHiddenValidatorSeatsPerShard: z.ZodMiniArray<z.ZodMiniNumber<number>>;
+    blockProducerKickoutThreshold: z.ZodMiniNumber<number>;
+    chainId: z.ZodMiniString<string>;
+    chunkProducerKickoutThreshold: z.ZodMiniNumber<number>;
+    chunkValidatorOnlyKickoutThreshold: z.ZodMiniNumber<number>;
+    dynamicResharding: z.ZodMiniBoolean<boolean>;
+    epochLength: z.ZodMiniNumber<number>;
+    fishermenThreshold: z.ZodMiniString<string>;
+    gasLimit: z.ZodMiniNumber<number>;
+    gasPriceAdjustmentRate: z.ZodMiniArray<z.ZodMiniNumber<number>>;
+    genesisHeight: z.ZodMiniNumber<number>;
+    genesisTime: z.ZodMiniString<string>;
+    maxGasPrice: z.ZodMiniString<string>;
+    maxInflationRate: z.ZodMiniArray<z.ZodMiniNumber<number>>;
+    maxKickoutStakePerc: z.ZodMiniNumber<number>;
+    minGasPrice: z.ZodMiniString<string>;
+    minimumStakeDivisor: z.ZodMiniNumber<number>;
+    minimumStakeRatio: z.ZodMiniArray<z.ZodMiniNumber<number>>;
+    minimumValidatorsPerShard: z.ZodMiniNumber<number>;
+    numBlockProducerSeats: z.ZodMiniNumber<number>;
+    numBlockProducerSeatsPerShard: z.ZodMiniArray<z.ZodMiniNumber<number>>;
+    numBlocksPerYear: z.ZodMiniNumber<number>;
+    onlineMaxThreshold: z.ZodMiniArray<z.ZodMiniNumber<number>>;
+    onlineMinThreshold: z.ZodMiniArray<z.ZodMiniNumber<number>>;
+    protocolRewardRate: z.ZodMiniArray<z.ZodMiniNumber<number>>;
+    protocolTreasuryAccount: z.ZodMiniLazy<z.ZodMiniString<string>>;
+    protocolUpgradeStakeThreshold: z.ZodMiniArray<z.ZodMiniNumber<number>>;
+    protocolVersion: z.ZodMiniNumber<number>;
+    shardLayout: z.ZodMiniLazy<z.ZodMiniUnion<readonly [z.ZodMiniObject<{
+        V0: z.ZodMiniLazy<z.ZodMiniObject<{
+            numShards: z.ZodMiniNumber<number>;
+            version: z.ZodMiniNumber<number>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodMiniObject<{
+        V1: z.ZodMiniLazy<z.ZodMiniObject<{
+            boundaryAccounts: z.ZodMiniArray<z.ZodMiniLazy<z.ZodMiniString<string>>>;
+            shardsSplitMap: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniUnion<readonly [z.ZodMiniArray<z.ZodMiniArray<z.ZodMiniLazy<z.ZodMiniNumber<number>>>>, z.ZodMiniNull]>, z.ZodMiniNull]>>;
+            toParentShardMap: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniUnion<readonly [z.ZodMiniArray<z.ZodMiniLazy<z.ZodMiniNumber<number>>>, z.ZodMiniNull]>, z.ZodMiniNull]>>;
+            version: z.ZodMiniNumber<number>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodMiniObject<{
+        V2: z.ZodMiniLazy<z.ZodMiniObject<{
+            boundaryAccounts: z.ZodMiniArray<z.ZodMiniLazy<z.ZodMiniString<string>>>;
+            idToIndexMap: z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniNumber<number>>;
+            indexToIdMap: z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniLazy<z.ZodMiniNumber<number>>>;
+            shardIds: z.ZodMiniArray<z.ZodMiniLazy<z.ZodMiniNumber<number>>>;
+            shardsParentMap: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniUnion<readonly [z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniLazy<z.ZodMiniNumber<number>>>, z.ZodMiniNull]>, z.ZodMiniNull]>>;
+            shardsSplitMap: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniUnion<readonly [z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniLazy<z.ZodMiniNumber<number>>>>, z.ZodMiniNull]>, z.ZodMiniNull]>>;
+            version: z.ZodMiniNumber<number>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>]>>;
+    shuffleShardAssignmentForChunkProducers: z.ZodMiniBoolean<boolean>;
+    targetValidatorMandatesPerShard: z.ZodMiniNumber<number>;
+    transactionValidityPeriod: z.ZodMiniNumber<number>;
+}, z.core.$strip>;
+type TemporaryProtocolConfig = z.infer<typeof TemporaryProtocolConfigShema>;
+
+type GetProtocolConfigArgs = {
+    atMomentOf?: BlockReference;
+};
+type GetProtocolConfigResult = TemporaryProtocolConfig;
+type GetProtocolConfig = (args?: GetProtocolConfigArgs) => Promise<GetProtocolConfigResult>;
+
+type CreateAccountAction = {
+    actionType: 'CreateAccount';
+};
+
+type TransferActionParams = {
+    amount: NearOption;
+};
+type TransferAction = {
+    actionType: 'Transfer';
+    params: TransferActionParams;
+};
+
+type FullAccessKeyParams = {
+    accessType: 'FullAccess';
+    publicKey: PublicKey;
+};
+type FunctionCallKeyParams = {
+    accessType: 'FunctionCall';
+    publicKey: PublicKey;
+    contractAccountId: AccountId;
+    gasBudget?: NearOption;
+    allowedFunctions?: ContractFunctionName[];
+};
+type AddKeyAction = {
+    actionType: 'AddKey';
+    params: FullAccessKeyParams | FunctionCallKeyParams;
+};
+
+type FnArgsJson<AJ extends JsonLikeValue> = {
+    fnArgsJson: AJ;
+    fnArgsBytes?: never;
+};
+type FnArgsBytes = {
+    fnArgsJson?: never;
+    fnArgsBytes?: Uint8Array;
+};
+type FnArgs<AJ extends MaybeJsonLikeValue = undefined> = [AJ] extends [
+    JsonLikeValue
+] ? FnArgsJson<AJ> : FnArgsBytes;
+
+type FunctionCallBase = {
+    functionName: ContractFunctionName;
+    gasLimit: GasOption;
+    attachedDeposit?: NearOption;
+};
+type FunctionCallParams<AJ extends MaybeJsonLikeValue> = FunctionCallBase & FnArgs<AJ>;
+type FunctionCallAction<AJ extends MaybeJsonLikeValue> = {
+    actionType: 'FunctionCall';
+    params: FunctionCallParams<AJ>;
+};
+
+type DeleteKeyActionParams = {
+    publicKey: PublicKey;
+};
+type DeleteKeyAction = {
+    actionType: 'DeleteKey';
+    params: DeleteKeyActionParams;
+};
+
+type DeleteAccountActionParams = {
+    beneficiaryAccountId: AccountId;
+};
+type DeleteAccountAction = {
+    actionType: 'DeleteAccount';
+    params: DeleteAccountActionParams;
+};
+
+type WasmBase64 = {
+    wasmBase64: Base64String;
+    wasmBytes?: never;
+};
+type WasmBytes = {
+    wasmBase64?: never;
+    wasmBytes: Uint8Array;
+};
+type DeployContractActionParams = WasmBase64 | WasmBytes;
+type DeployContractAction = {
+    actionType: 'DeployContract';
+    params: DeployContractActionParams;
+};
+
+type Action = CreateAccountAction | TransferAction | AddKeyAction | DeployContractAction | FunctionCallAction<MaybeJsonLikeValue> | DeleteKeyAction | DeleteAccountAction;
+type SingleAction = {
+    action: Action;
+    actions?: never;
+};
+type MultiActions = {
+    action?: never;
+    actions: Action[];
+};
+type TransactionBase = {
+    signerAccountId: AccountId;
+    signerPublicKey: PublicKey;
+    receiverAccountId: AccountId;
+    nonce: Nonce;
+    blockHash: BlockHash;
+};
+type Transaction = TransactionBase & (SingleAction | MultiActions);
+type TransactionIntent = {
+    receiverAccountId: AccountId;
+} & (SingleAction | MultiActions);
+/**
+ *  <h3>Transaction Execution Levels:</h3>
+ *
+ *  **None**: Transaction is waiting to be included into the block
+ *
+ *  **Included**: Transaction is included into the block. The block may be not finalized yet
+ *
+ *  **ExecutedOptimistic**: Transaction is included into the block +
+ *  all non-refund transaction receipts finished their execution.
+ *  The corresponding blocks for tx and each receipt may be not finalized yet
+ *
+ *  **IncludedFinal**: Transaction is included into finalized block
+ *
+ *  **Executed**: Transaction is included into finalized block +
+ *  All non-refund transaction receipts finished their execution.
+ *  The corresponding blocks for each receipt may be not finalized yet
+ *
+ *  **Final**: Transaction is included into finalized block +
+ *  Execution of all transaction receipts is finalized, including refund receipts
+ */
+type TransactionExecutionStatus = 'None' | 'Included' | 'ExecutedOptimistic' | 'IncludedFinal' | 'Executed' | 'Final';
+
+type SignedTransaction = {
+    transaction: Transaction;
+    transactionHash: CryptoHash;
+    signature: Signature;
+};
+
+type SendSignedTransactionArgs = {
+    signedTransaction: SignedTransaction;
+    waitUntil?: TransactionExecutionStatus;
+};
+type SendSignedTransactionResult = RpcTransactionResponse;
+type SendSignedTransaction = (args: SendSignedTransactionArgs) => Promise<SendSignedTransactionResult>;
+
+type GetContractStateArgs = {
+    contractAccountId: AccountId;
+    keyPrefix?: string;
+    includeProof?: boolean;
+    atMomentOf?: BlockReference;
+};
+type StateRecord = {
+    key: Base64String;
+    value: Base64String;
+};
+type GetContractStateResult = {
+    blockHash: BlockHash;
+    blockHeight: BlockHeight;
+    contractAccountId: AccountId;
+    proof?: Base64String[];
+    contractState: StateRecord[];
+};
+type GetContractState = (args: GetContractStateArgs) => Promise<GetContractStateResult>;
+
+/**
+ * Utility type that conditionally includes a key in an object:
+ *
+ * - If `V` is `undefined`, the key `K` is optional and must never be provided
+ *   (acts as a "poison pill" to exclude the field).
+ * - Otherwise, the key `K` is required with value type `V`.
+ *
+ * Examples:
+ * ```ts
+ *  type A = KeyIf<'foo', string>; // => { foo: string }
+ *  type B = KeyIf<'bar', undefined>; // => { bar?: never }
+ *
+ *  // When combined in an intersection:
+ *  type C = KeyIf<'foo', string> & KeyIf<'bar', undefined>;
+ *  // => { foo: string; bar?: never }
+ * ```
+ */
+type KeyIf<K extends PropertyKey, V> = [V] extends [undefined] ? {
+    [P in K]?: never;
+} : {
+    [P in K]: V;
+};
+/**
+ * Utility type that "prettifies" an object type for IDE hints.
+ *
+ * TypeScript often shows type aliases, intersections, and conditional types
+ * in their raw form (e.g. `Result<SomeType>` or `A & B`) instead of expanding
+ * them into a flat object structure.
+ *
+ * `Prettify<T>` remaps the properties of `T` into a new object type,
+ * effectively "flattening" the type so that IDE hovers display a clean,
+ * expanded shape.
+ *
+ * Notice: it doesn't touch the nested types - to do it you need to use a recursive type.
+ *
+ * Examples:
+ * ```ts
+ * type Raw = { a: number } & { b: string };
+ * // Hover shows: { a: number } & { b: string }
+ *
+ * type Pretty = Prettify<Raw>;
+ * // Hover shows: { a: number; b: string }
+ * ```
+ */
+type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+
+type RawCallResult = number[];
+type RawCallLogs = string[];
+type BaseDeserializeResult = ({ rawResult, }: {
+    rawResult: RawCallResult;
+}) => unknown;
+type MaybeBaseDeserializeResult = BaseDeserializeResult | undefined;
+type BaseSerializeArgs<A> = (args: {
+    functionArgs: A;
+}) => Uint8Array;
+type BaseFnCallArgs = {
+    contractAccountId: AccountId;
+    functionName: ContractFunctionName;
+    withStateAt?: BlockReference;
+};
+type Options<A, SR extends BaseSerializeArgs<A> | undefined, DR extends MaybeBaseDeserializeResult> = [SR, DR] extends [undefined, undefined] ? {
+    options?: never;
+} : {
+    options: KeyIf<'serializeArgs', SR> & KeyIf<'deserializeResult', DR>;
+};
+type FunctionArgs<A> = KeyIf<'functionArgs', A>;
+type Result<R> = Prettify<{
+    blockHash: BlockHash;
+    blockHeight: BlockHeight;
+    logs: RawCallLogs;
+    result: R;
+}>;
+type CallResult<DR extends MaybeBaseDeserializeResult> = [DR] extends [
+    BaseDeserializeResult
+] ? Promise<Result<ReturnType<DR>>> : Promise<Result<unknown>>;
+type FunctionArgsOf<SA> = SA extends (args: {
+    functionArgs: infer T;
+}) => Uint8Array ? T : undefined;
+type CallContractReadFunction = {
+    <A extends MaybeJsonLikeValue = undefined>(args: BaseFnCallArgs & FunctionArgs<A> & Options<undefined, undefined, undefined>): CallResult<undefined>;
+    <DR extends BaseDeserializeResult, A extends MaybeJsonLikeValue = undefined>(args: BaseFnCallArgs & FunctionArgs<A> & Options<undefined, undefined, DR>): CallResult<DR>;
+    <SA extends BaseSerializeArgs<A>, DR extends MaybeBaseDeserializeResult = undefined, A = FunctionArgsOf<SA>>(args: BaseFnCallArgs & FunctionArgs<A> & Options<A, SA, DR>): CallResult<DR>;
+};
+
+type Rpc = {
+    url: string;
+    headers?: Record<string, string>;
+};
+type Network = {
+    rpcs: {
+        regular: Rpc[];
+        archival: Rpc[];
+    };
+};
+type Input = {
+    network: Network;
+};
+type Client = {
+    getAccountState: GetAccountState;
+    getAccountKey: GetAccountKey;
+    getAccountKeys: GetAccountKeys;
+    getContractState: GetContractState;
+    callContractReadFunction: CallContractReadFunction;
+    getBlock: GetBlock;
+    getProtocolConfig: GetProtocolConfig;
+    getGasPrice: GetGasPrice;
+    sendSignedTransaction: SendSignedTransaction;
+};
+type CreateClient = (input: Input) => Client;
+
+declare const createClient: CreateClient;
+
+declare const mainnet: Network;
+declare const testnet: Network;
+
+type KeySource = {
+    privateKey: PrivateKey;
+} | {
+    seedPhrase: string;
+};
+type SingleKeySource = {
+    keySource: KeySource;
+    keySources?: never;
+};
+type MultiKeySources = {
+    keySource?: never;
+    keySources: KeySource[];
+};
+type CreateMemoryKeyServiceInput = SingleKeySource | MultiKeySources;
+type KeyPairs = Record<PublicKey, PrivateKey>;
+type SignTransaction = (transaction: Transaction) => Promise<SignedTransaction>;
+type MemoryKeyService = {
+    signTransaction: SignTransaction;
+    getKeyPairs: () => KeyPairs;
+};
+
+declare const createMemoryKeyService: (params: CreateMemoryKeyServiceInput) => Promise<MemoryKeyService>;
+
+type ExecuteMultipleTransactionsResult = ({
+    status: 'Success';
+    result: SendSignedTransactionResult;
+} | {
+    status: 'Error';
+    error: unknown;
+} | {
+    status: 'Canceled';
+})[];
+type SignMultipleTransactionsResult = ({
+    status: 'Success';
+    result: SignedTransaction;
+} | {
+    status: 'Error';
+    error: unknown;
+} | {
+    status: 'Canceled';
+})[];
+type MemorySigner = {
+    executeTransaction: (args: TransactionIntent) => Promise<SendSignedTransactionResult>;
+    executeMultipleTransactions: (args: {
+        transactionIntents: TransactionIntent[];
+    }) => Promise<ExecuteMultipleTransactionsResult>;
+    signTransaction: (args: TransactionIntent) => Promise<SignedTransaction>;
+    signMultipleTransactions: (args: {
+        transactionIntents: TransactionIntent[];
+    }) => Promise<SignMultipleTransactionsResult>;
+};
+type CreateMemorySignerArgs = {
+    signerAccountId: AccountId;
+    client: Client;
+    keyService: MemoryKeyService;
+    keyPool?: {
+        signingKeys?: PublicKey[];
+    };
+    queue?: {
+        taskTtlMs?: number;
+    };
+};
+type CreateMemorySigner = (args: CreateMemorySignerArgs) => Promise<MemorySigner>;
+
+declare const createMemorySigner: CreateMemorySigner;
+
+declare const transfer: (params: TransferActionParams) => TransferAction;
+
+declare const createAccount: () => CreateAccountAction;
+
+declare const addFullAccessKey: ({ publicKey, }: Omit<FullAccessKeyParams, "accessType">) => AddKeyAction;
+
+declare const addFunctionCallKey: ({ publicKey, contractAccountId, gasBudget, allowedFunctions, }: Omit<FunctionCallKeyParams, "accessType">) => AddKeyAction;
+
+declare const functionCall: <AJ extends MaybeJsonLikeValue>(params: FunctionCallParams<AJ>) => FunctionCallAction<AJ>;
+
+declare const deleteKey: (params: DeleteKeyActionParams) => DeleteKeyAction;
+
+declare const deleteAccount: (params: DeleteAccountActionParams) => DeleteAccountAction;
+
+declare const deployContract: (params: DeployContractActionParams) => DeployContractAction;
+
+declare const yoctoNear: (units: Units) => NearToken;
+declare const near: (tokens: Tokens) => NearToken;
+
+declare const gas: (gas: GasInput) => {
+    gas: bigint;
+    teraGas: string;
+};
+declare const teraGas: (teraGas: TeraGasInput) => {
+    gas: bigint;
+    teraGas: string;
+};
+
+export { addFullAccessKey, addFunctionCallKey, createAccount, createClient, createMemoryKeyService, createMemorySigner, deleteAccount, deleteKey, deployContract, functionCall, gas, mainnet, near, teraGas, testnet, transfer, yoctoNear };