aptos
Version:
1,387 lines (1,362 loc) • 318 kB
JavaScript
"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var __decorateClass = (decorators, target, key, kind) => {
var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
for (var i = decorators.length - 1, decorator; i >= 0; i--)
if (decorator = decorators[i])
result = (kind ? decorator(target, key, result) : decorator(result)) || result;
if (kind && result)
__defProp(target, key, result);
return result;
};
// src/index.ts
var src_exports = {};
__export(src_exports, {
APTOS_COIN: () => APTOS_COIN,
AccountSequenceNumber: () => AccountSequenceNumber,
Account_Transactions_Select_Column: () => Account_Transactions_Select_Column,
Address_Events_Summary_Select_Column: () => Address_Events_Summary_Select_Column,
Address_Version_From_Events_Select_Column: () => Address_Version_From_Events_Select_Column,
Address_Version_From_Move_Resources_Select_Column: () => Address_Version_From_Move_Resources_Select_Column,
AnsClient: () => AnsClient,
ApiError: () => ApiError,
AptosAccount: () => AptosAccount,
AptosApiError: () => AptosApiError,
AptosClient: () => AptosClient,
AptosToken: () => AptosToken,
BCS: () => bcs_exports,
Block_Metadata_Transactions_Select_Column: () => Block_Metadata_Transactions_Select_Column,
CKDPriv: () => CKDPriv,
COIN_TRANSFER: () => COIN_TRANSFER,
CoinClient: () => CoinClient,
Coin_Activities_Select_Column: () => Coin_Activities_Select_Column,
Coin_Balances_Select_Column: () => Coin_Balances_Select_Column,
Coin_Infos_Select_Column: () => Coin_Infos_Select_Column,
Coin_Supply_Select_Column: () => Coin_Supply_Select_Column,
Collection_Datas_Select_Column: () => Collection_Datas_Select_Column,
Current_Ans_Lookup_Select_Column: () => Current_Ans_Lookup_Select_Column,
Current_Ans_Lookup_V2_Select_Column: () => Current_Ans_Lookup_V2_Select_Column,
Current_Aptos_Names_Select_Column: () => Current_Aptos_Names_Select_Column,
Current_Coin_Balances_Select_Column: () => Current_Coin_Balances_Select_Column,
Current_Collection_Datas_Select_Column: () => Current_Collection_Datas_Select_Column,
Current_Collection_Ownership_V2_View_Select_Column: () => Current_Collection_Ownership_V2_View_Select_Column,
Current_Collections_V2_Select_Column: () => Current_Collections_V2_Select_Column,
Current_Delegated_Staking_Pool_Balances_Select_Column: () => Current_Delegated_Staking_Pool_Balances_Select_Column,
Current_Delegated_Voter_Select_Column: () => Current_Delegated_Voter_Select_Column,
Current_Delegator_Balances_Select_Column: () => Current_Delegator_Balances_Select_Column,
Current_Fungible_Asset_Balances_Select_Column: () => Current_Fungible_Asset_Balances_Select_Column,
Current_Objects_Select_Column: () => Current_Objects_Select_Column,
Current_Staking_Pool_Voter_Select_Column: () => Current_Staking_Pool_Voter_Select_Column,
Current_Table_Items_Select_Column: () => Current_Table_Items_Select_Column,
Current_Token_Datas_Select_Column: () => Current_Token_Datas_Select_Column,
Current_Token_Datas_V2_Select_Column: () => Current_Token_Datas_V2_Select_Column,
Current_Token_Ownerships_Select_Column: () => Current_Token_Ownerships_Select_Column,
Current_Token_Ownerships_V2_Select_Column: () => Current_Token_Ownerships_V2_Select_Column,
Current_Token_Pending_Claims_Select_Column: () => Current_Token_Pending_Claims_Select_Column,
Cursor_Ordering: () => Cursor_Ordering,
Delegated_Staking_Activities_Select_Column: () => Delegated_Staking_Activities_Select_Column,
Delegated_Staking_Pools_Select_Column: () => Delegated_Staking_Pools_Select_Column,
Delegator_Distinct_Pool_Select_Column: () => Delegator_Distinct_Pool_Select_Column,
Events_Select_Column: () => Events_Select_Column,
FailedTransactionError: () => FailedTransactionError,
FaucetClient: () => FaucetClient,
FungibleAssetClient: () => FungibleAssetClient,
Fungible_Asset_Activities_Select_Column: () => Fungible_Asset_Activities_Select_Column,
Fungible_Asset_Metadata_Select_Column: () => Fungible_Asset_Metadata_Select_Column,
HexString: () => HexString,
IndexerClient: () => IndexerClient,
Indexer_Status_Select_Column: () => Indexer_Status_Select_Column,
Ledger_Infos_Select_Column: () => Ledger_Infos_Select_Column,
Move_Resources_Select_Column: () => Move_Resources_Select_Column,
Network: () => Network,
NetworkToIndexerAPI: () => NetworkToIndexerAPI,
NetworkToNodeAPI: () => NetworkToNodeAPI,
Nft_Marketplace_V2_Current_Nft_Marketplace_Auctions_Select_Column: () => Nft_Marketplace_V2_Current_Nft_Marketplace_Auctions_Select_Column,
Nft_Marketplace_V2_Current_Nft_Marketplace_Collection_Offers_Select_Column: () => Nft_Marketplace_V2_Current_Nft_Marketplace_Collection_Offers_Select_Column,
Nft_Marketplace_V2_Current_Nft_Marketplace_Listings_Select_Column: () => Nft_Marketplace_V2_Current_Nft_Marketplace_Listings_Select_Column,
Nft_Marketplace_V2_Current_Nft_Marketplace_Token_Offers_Select_Column: () => Nft_Marketplace_V2_Current_Nft_Marketplace_Token_Offers_Select_Column,
Nft_Marketplace_V2_Nft_Marketplace_Activities_Select_Column: () => Nft_Marketplace_V2_Nft_Marketplace_Activities_Select_Column,
Nft_Metadata_Crawler_Parsed_Asset_Uris_Select_Column: () => Nft_Metadata_Crawler_Parsed_Asset_Uris_Select_Column,
NodeAPIToNetwork: () => NodeAPIToNetwork,
Num_Active_Delegator_Per_Pool_Select_Column: () => Num_Active_Delegator_Per_Pool_Select_Column,
Order_By: () => Order_By,
Processor_Status_Select_Column: () => Processor_Status_Select_Column,
PropertyMap: () => PropertyMap,
PropertyValue: () => PropertyValue,
Proposal_Votes_Select_Column: () => Proposal_Votes_Select_Column,
Provider: () => Provider,
TRANSFER_COINS: () => TRANSFER_COINS,
Table_Items_Select_Column: () => Table_Items_Select_Column,
Table_Metadatas_Select_Column: () => Table_Metadatas_Select_Column,
TokenClient: () => TokenClient,
TokenTypes: () => token_types_exports,
Token_Activities_Select_Column: () => Token_Activities_Select_Column,
Token_Activities_V2_Select_Column: () => Token_Activities_V2_Select_Column,
Token_Datas_Select_Column: () => Token_Datas_Select_Column,
Token_Ownerships_Select_Column: () => Token_Ownerships_Select_Column,
Tokens_Select_Column: () => Tokens_Select_Column,
TransactionBuilder: () => TransactionBuilder,
TransactionBuilderABI: () => TransactionBuilderABI,
TransactionBuilderEd25519: () => TransactionBuilderEd25519,
TransactionBuilderMultiEd25519: () => TransactionBuilderMultiEd25519,
TransactionBuilderRemoteABI: () => TransactionBuilderRemoteABI,
TransactionWorker: () => TransactionWorker,
TransactionWorkerEvents: () => TransactionWorkerEvents,
TxnBuilderTypes: () => aptos_types_exports,
TypeTagParser: () => TypeTagParser,
Types: () => generated_exports,
User_Transactions_Select_Column: () => User_Transactions_Select_Column,
WaitForTransactionError: () => WaitForTransactionError,
ansContractsMap: () => ansContractsMap,
aptosRequest: () => aptosRequest,
argToTransactionArgument: () => argToTransactionArgument,
derivePath: () => derivePath,
deserializePropertyMap: () => deserializePropertyMap,
deserializeValueBasedOnTypeTag: () => deserializeValueBasedOnTypeTag,
ensureBigInt: () => ensureBigInt,
ensureBoolean: () => ensureBoolean,
ensureNumber: () => ensureNumber,
get: () => get,
getAddressFromAccountOrAddress: () => getAddressFromAccountOrAddress,
getMasterKeyFromSeed: () => getMasterKeyFromSeed,
getPropertyType: () => getPropertyType,
getPropertyValueRaw: () => getPropertyValueRaw,
getPublicKey: () => getPublicKey,
getSinglePropertyValueRaw: () => getSinglePropertyValueRaw,
isValidPath: () => isValidPath,
nameComponentPattern: () => nameComponentPattern,
namePattern: () => namePattern,
post: () => post,
serializeArg: () => serializeArg
});
module.exports = __toCommonJS(src_exports);
// src/account/aptos_account.ts
var import_tweetnacl2 = __toESM(require("tweetnacl"));
var bip39 = __toESM(require("@scure/bip39"));
var import_utils6 = require("@noble/hashes/utils");
var import_sha256 = require("@noble/hashes/sha256");
var import_sha33 = require("@noble/hashes/sha3");
// src/utils/hd-key.ts
var import_tweetnacl = __toESM(require("tweetnacl"));
var import_hmac = require("@noble/hashes/hmac");
var import_sha512 = require("@noble/hashes/sha512");
var import_utils = require("@noble/hashes/utils");
var pathRegex = /^m(\/[0-9]+')+$/;
var replaceDerive = (val) => val.replace("'", "");
var HMAC_KEY = "ed25519 seed";
var HARDENED_OFFSET = 2147483648;
var getMasterKeyFromSeed = (seed) => {
const h = import_hmac.hmac.create(import_sha512.sha512, HMAC_KEY);
const I = h.update((0, import_utils.hexToBytes)(seed)).digest();
const IL = I.slice(0, 32);
const IR = I.slice(32);
return {
key: IL,
chainCode: IR
};
};
var CKDPriv = ({ key, chainCode }, index) => {
const buffer = new ArrayBuffer(4);
new DataView(buffer).setUint32(0, index);
const indexBytes = new Uint8Array(buffer);
const zero = new Uint8Array([0]);
const data = new Uint8Array([...zero, ...key, ...indexBytes]);
const I = import_hmac.hmac.create(import_sha512.sha512, chainCode).update(data).digest();
const IL = I.slice(0, 32);
const IR = I.slice(32);
return {
key: IL,
chainCode: IR
};
};
var getPublicKey = (privateKey, withZeroByte = true) => {
const keyPair = import_tweetnacl.default.sign.keyPair.fromSeed(privateKey);
const signPk = keyPair.secretKey.subarray(32);
const zero = new Uint8Array([0]);
return withZeroByte ? new Uint8Array([...zero, ...signPk]) : signPk;
};
var isValidPath = (path) => {
if (!pathRegex.test(path)) {
return false;
}
return !path.split("/").slice(1).map(replaceDerive).some(Number.isNaN);
};
var derivePath = (path, seed, offset = HARDENED_OFFSET) => {
if (!isValidPath(path)) {
throw new Error("Invalid derivation path");
}
const { key, chainCode } = getMasterKeyFromSeed(seed);
const segments = path.split("/").slice(1).map(replaceDerive).map((el) => parseInt(el, 10));
return segments.reduce((parentKeys, segment) => CKDPriv(parentKeys, segment + offset), { key, chainCode });
};
// src/version.ts
var VERSION = "1.21.0";
// src/utils/misc.ts
async function sleep(timeMs) {
return new Promise((resolve) => {
setTimeout(resolve, timeMs);
});
}
var DEFAULT_VERSION_PATH_BASE = "/v1";
function fixNodeUrl(nodeUrl) {
let out = `${nodeUrl}`;
if (out.endsWith("/")) {
out = out.substring(0, out.length - 1);
}
if (!out.endsWith(DEFAULT_VERSION_PATH_BASE)) {
out = `${out}${DEFAULT_VERSION_PATH_BASE}`;
}
return out;
}
var DEFAULT_MAX_GAS_AMOUNT = 2e5;
var DEFAULT_TXN_EXP_SEC_FROM_NOW = 20;
var DEFAULT_TXN_TIMEOUT_SEC = 20;
var APTOS_COIN = "0x1::aptos_coin::AptosCoin";
var CUSTOM_REQUEST_HEADER = { "x-aptos-client": `aptos-ts-sdk/${VERSION}` };
// src/utils/memoize-decorator.ts
function Memoize(args) {
let hashFunction;
let ttlMs;
let tags;
if (typeof args === "object") {
hashFunction = args.hashFunction;
ttlMs = args.ttlMs;
tags = args.tags;
} else {
hashFunction = args;
}
return (target, propertyKey, descriptor) => {
if (descriptor.value != null) {
descriptor.value = getNewFunction(descriptor.value, hashFunction, ttlMs, tags);
} else if (descriptor.get != null) {
descriptor.get = getNewFunction(descriptor.get, hashFunction, ttlMs, tags);
} else {
throw new Error("Only put a Memoize() decorator on a method or get accessor.");
}
};
}
function MemoizeExpiring(ttlMs, hashFunction) {
return Memoize({
ttlMs,
hashFunction
});
}
var clearCacheTagsMap = /* @__PURE__ */ new Map();
function clear(tags) {
const cleared = /* @__PURE__ */ new Set();
for (const tag of tags) {
const maps = clearCacheTagsMap.get(tag);
if (maps) {
for (const mp of maps) {
if (!cleared.has(mp)) {
mp.clear();
cleared.add(mp);
}
}
}
}
return cleared.size;
}
function getNewFunction(originalMethod, hashFunction, ttlMs = 0, tags) {
const propMapName = Symbol("__memoized_map__");
return function(...args) {
let returnedValue;
const that = this;
if (!that.hasOwnProperty(propMapName)) {
Object.defineProperty(that, propMapName, {
configurable: false,
enumerable: false,
writable: false,
value: /* @__PURE__ */ new Map()
});
}
const myMap = that[propMapName];
if (Array.isArray(tags)) {
for (const tag of tags) {
if (clearCacheTagsMap.has(tag)) {
clearCacheTagsMap.get(tag).push(myMap);
} else {
clearCacheTagsMap.set(tag, [myMap]);
}
}
}
if (hashFunction || args.length > 0 || ttlMs > 0) {
let hashKey;
if (hashFunction === true) {
hashKey = args.map((a) => a.toString()).join("!");
} else if (hashFunction) {
hashKey = hashFunction.apply(that, args);
} else {
hashKey = args[0];
}
const timestampKey = `${hashKey}__timestamp`;
let isExpired = false;
if (ttlMs > 0) {
if (!myMap.has(timestampKey)) {
isExpired = true;
} else {
const timestamp = myMap.get(timestampKey);
isExpired = Date.now() - timestamp > ttlMs;
}
}
if (myMap.has(hashKey) && !isExpired) {
returnedValue = myMap.get(hashKey);
} else {
returnedValue = originalMethod.apply(that, args);
myMap.set(hashKey, returnedValue);
if (ttlMs > 0) {
myMap.set(timestampKey, Date.now());
}
}
} else {
const hashKey = that;
if (myMap.has(hashKey)) {
returnedValue = myMap.get(hashKey);
} else {
returnedValue = originalMethod.apply(that, args);
myMap.set(hashKey, returnedValue);
}
}
return returnedValue;
};
}
// src/client/core.ts
var import_aptos_client = __toESM(require("@aptos-labs/aptos-client"));
// src/client/types.ts
var AptosApiError = class extends Error {
constructor(request2, response, message) {
super(message);
this.name = "AptosApiError";
this.url = response.url;
this.status = response.status;
this.statusText = response.statusText;
this.data = response.data;
this.request = request2;
}
};
// src/client/core.ts
var errors = {
400: "Bad Request",
401: "Unauthorized",
403: "Forbidden",
404: "Not Found",
429: "Too Many Requests",
500: "Internal Server Error",
502: "Bad Gateway",
503: "Service Unavailable"
};
async function request(url, method, body, contentType, params, overrides) {
const headers = {
...overrides == null ? void 0 : overrides.HEADERS,
"x-aptos-client": `aptos-ts-sdk/${VERSION}`,
"content-type": contentType != null ? contentType : "application/json"
};
if (overrides == null ? void 0 : overrides.TOKEN) {
headers.Authorization = `Bearer ${overrides == null ? void 0 : overrides.TOKEN}`;
}
const response = await (0, import_aptos_client.default)({ url, method, body, params, headers, overrides });
return response;
}
async function aptosRequest(options) {
const { url, endpoint, method, body, contentType, params, overrides } = options;
const fullEndpoint = `${url}/${endpoint != null ? endpoint : ""}`;
const response = await request(fullEndpoint, method, body, contentType, params, overrides);
const result = {
status: response.status,
statusText: response.statusText,
data: response.data,
headers: response.headers,
config: response.config,
url: fullEndpoint
};
if (result.status >= 200 && result.status < 300) {
return result;
}
const errorMessage = errors[result.status];
throw new AptosApiError(options, result, errorMessage != null ? errorMessage : "Generic Error");
}
// src/client/get.ts
async function get(options) {
const response = await aptosRequest({ ...options, method: "GET" });
return response;
}
// src/client/post.ts
async function post(options) {
const response = await aptosRequest({ ...options, method: "POST" });
return response;
}
// src/utils/pagination_helpers.ts
async function paginateWithCursor(options) {
const out = [];
let cursor;
const requestParams = options.params;
while (true) {
requestParams.start = cursor;
const response = await get({
url: options.url,
endpoint: options.endpoint,
params: requestParams,
originMethod: options.originMethod,
overrides: options.overrides
});
cursor = response.headers["x-aptos-cursor"];
delete response.headers;
out.push(...response.data);
if (cursor === null || cursor === void 0) {
break;
}
}
return out;
}
// src/utils/api-endpoints.ts
var NetworkToIndexerAPI = {
mainnet: "https://indexer.mainnet.aptoslabs.com/v1/graphql",
testnet: "https://indexer-testnet.staging.gcp.aptosdev.com/v1/graphql",
devnet: "https://indexer-devnet.staging.gcp.aptosdev.com/v1/graphql",
local: "http://127.0.0.1:8090/v1/graphql"
};
var NetworkToNodeAPI = {
mainnet: "https://fullnode.mainnet.aptoslabs.com/v1",
testnet: "https://fullnode.testnet.aptoslabs.com/v1",
devnet: "https://fullnode.devnet.aptoslabs.com/v1",
local: "http://127.0.0.1:8080/v1"
};
var NodeAPIToNetwork = {
"https://fullnode.mainnet.aptoslabs.com/v1": "mainnet",
"https://fullnode.testnet.aptoslabs.com/v1": "testnet",
"https://fullnode.devnet.aptoslabs.com/v1": "devnet",
"http://127.0.0.1:8080/v1": "local"
};
var Network = /* @__PURE__ */ ((Network3) => {
Network3["MAINNET"] = "mainnet";
Network3["TESTNET"] = "testnet";
Network3["DEVNET"] = "devnet";
Network3["LOCAL"] = "local";
return Network3;
})(Network || {});
// src/utils/hex_string.ts
var import_utils2 = require("@noble/hashes/utils");
var HexString = class _HexString {
/**
* Creates new hex string from Buffer
* @param buffer A buffer to convert
* @returns New HexString
*/
static fromBuffer(buffer) {
return _HexString.fromUint8Array(buffer);
}
/**
* Creates new hex string from Uint8Array
* @param arr Uint8Array to convert
* @returns New HexString
*/
static fromUint8Array(arr) {
return new _HexString((0, import_utils2.bytesToHex)(arr));
}
/**
* Ensures `hexString` is instance of `HexString` class
* @param hexString String to check
* @returns New HexString if `hexString` is regular string or `hexString` if it is HexString instance
* @example
* ```
* const regularString = "string";
* const hexString = new HexString("string"); // "0xstring"
* HexString.ensure(regularString); // "0xstring"
* HexString.ensure(hexString); // "0xstring"
* ```
*/
static ensure(hexString) {
if (typeof hexString === "string") {
return new _HexString(hexString);
}
return hexString;
}
/**
* Creates new HexString instance from regular string. If specified string already starts with "0x" prefix,
* it will not add another one
* @param hexString String to convert
* @example
* ```
* const string = "string";
* new HexString(string); // "0xstring"
* ```
*/
constructor(hexString) {
if (hexString.startsWith("0x")) {
this.hexString = hexString;
} else {
this.hexString = `0x${hexString}`;
}
}
/**
* Getter for inner hexString
* @returns Inner hex string
*/
hex() {
return this.hexString;
}
/**
* Getter for inner hexString without prefix
* @returns Inner hex string without prefix
* @example
* ```
* const hexString = new HexString("string"); // "0xstring"
* hexString.noPrefix(); // "string"
* ```
*/
noPrefix() {
return this.hexString.slice(2);
}
/**
* Overrides default `toString` method
* @returns Inner hex string
*/
toString() {
return this.hex();
}
/**
* Trimmes extra zeroes in the begining of a string
* @returns Inner hexString without leading zeroes
* @example
* ```
* new HexString("0x000000string").toShortString(); // result = "0xstring"
* ```
*/
toShortString() {
const trimmed = this.hexString.replace(/^0x0*/, "");
return `0x${trimmed}`;
}
/**
* Converts hex string to a Uint8Array
* @returns Uint8Array from inner hexString without prefix
*/
toUint8Array() {
return Uint8Array.from((0, import_utils2.hexToBytes)(this.noPrefix()));
}
};
// src/aptos_types/index.ts
var aptos_types_exports = {};
__export(aptos_types_exports, {
AccountAddress: () => AccountAddress,
AccountAuthenticator: () => AccountAuthenticator,
AccountAuthenticatorEd25519: () => AccountAuthenticatorEd25519,
AccountAuthenticatorMultiEd25519: () => AccountAuthenticatorMultiEd25519,
ArgumentABI: () => ArgumentABI,
AuthenticationKey: () => AuthenticationKey,
ChainId: () => ChainId,
ChangeSet: () => ChangeSet,
Ed25519PublicKey: () => Ed25519PublicKey,
Ed25519Signature: () => Ed25519Signature,
EntryFunction: () => EntryFunction,
EntryFunctionABI: () => EntryFunctionABI,
FeePayerRawTransaction: () => FeePayerRawTransaction,
Identifier: () => Identifier,
Module: () => Module,
ModuleId: () => ModuleId,
MultiAgentRawTransaction: () => MultiAgentRawTransaction,
MultiEd25519PublicKey: () => MultiEd25519PublicKey,
MultiEd25519Signature: () => MultiEd25519Signature,
MultiSig: () => MultiSig,
MultiSigTransactionPayload: () => MultiSigTransactionPayload,
RawTransaction: () => RawTransaction,
RawTransactionWithData: () => RawTransactionWithData,
RotationProofChallenge: () => RotationProofChallenge,
Script: () => Script,
ScriptABI: () => ScriptABI,
SignedTransaction: () => SignedTransaction,
StructTag: () => StructTag,
Transaction: () => Transaction,
TransactionArgument: () => TransactionArgument,
TransactionArgumentAddress: () => TransactionArgumentAddress,
TransactionArgumentBool: () => TransactionArgumentBool,
TransactionArgumentU128: () => TransactionArgumentU128,
TransactionArgumentU16: () => TransactionArgumentU16,
TransactionArgumentU256: () => TransactionArgumentU256,
TransactionArgumentU32: () => TransactionArgumentU32,
TransactionArgumentU64: () => TransactionArgumentU64,
TransactionArgumentU8: () => TransactionArgumentU8,
TransactionArgumentU8Vector: () => TransactionArgumentU8Vector,
TransactionAuthenticator: () => TransactionAuthenticator,
TransactionAuthenticatorEd25519: () => TransactionAuthenticatorEd25519,
TransactionAuthenticatorFeePayer: () => TransactionAuthenticatorFeePayer,
TransactionAuthenticatorMultiAgent: () => TransactionAuthenticatorMultiAgent,
TransactionAuthenticatorMultiEd25519: () => TransactionAuthenticatorMultiEd25519,
TransactionPayload: () => TransactionPayload,
TransactionPayloadEntryFunction: () => TransactionPayloadEntryFunction,
TransactionPayloadMultisig: () => TransactionPayloadMultisig,
TransactionPayloadScript: () => TransactionPayloadScript,
TransactionScriptABI: () => TransactionScriptABI,
TypeArgumentABI: () => TypeArgumentABI,
TypeTag: () => TypeTag,
TypeTagAddress: () => TypeTagAddress,
TypeTagBool: () => TypeTagBool,
TypeTagParser: () => TypeTagParser,
TypeTagParserError: () => TypeTagParserError,
TypeTagSigner: () => TypeTagSigner,
TypeTagStruct: () => TypeTagStruct,
TypeTagU128: () => TypeTagU128,
TypeTagU16: () => TypeTagU16,
TypeTagU256: () => TypeTagU256,
TypeTagU32: () => TypeTagU32,
TypeTagU64: () => TypeTagU64,
TypeTagU8: () => TypeTagU8,
TypeTagVector: () => TypeTagVector,
UserTransaction: () => UserTransaction,
WriteSet: () => WriteSet,
objectStructTag: () => objectStructTag,
optionStructTag: () => optionStructTag,
stringStructTag: () => stringStructTag
});
// src/bcs/index.ts
var bcs_exports = {};
__export(bcs_exports, {
Deserializer: () => Deserializer,
Serializer: () => Serializer,
bcsSerializeBool: () => bcsSerializeBool,
bcsSerializeBytes: () => bcsSerializeBytes,
bcsSerializeFixedBytes: () => bcsSerializeFixedBytes,
bcsSerializeStr: () => bcsSerializeStr,
bcsSerializeU128: () => bcsSerializeU128,
bcsSerializeU16: () => bcsSerializeU16,
bcsSerializeU256: () => bcsSerializeU256,
bcsSerializeU32: () => bcsSerializeU32,
bcsSerializeU8: () => bcsSerializeU8,
bcsSerializeUint64: () => bcsSerializeUint64,
bcsToBytes: () => bcsToBytes,
deserializeVector: () => deserializeVector,
serializeVector: () => serializeVector,
serializeVectorWithFunc: () => serializeVectorWithFunc
});
// src/bcs/consts.ts
var MAX_U8_NUMBER = 2 ** 8 - 1;
var MAX_U16_NUMBER = 2 ** 16 - 1;
var MAX_U32_NUMBER = 2 ** 32 - 1;
var MAX_U64_BIG_INT = BigInt(2 ** 64) - BigInt(1);
var MAX_U128_BIG_INT = BigInt(2 ** 128) - BigInt(1);
var MAX_U256_BIG_INT = BigInt(2 ** 256) - BigInt(1);
// src/bcs/serializer.ts
var Serializer = class {
constructor() {
this.buffer = new ArrayBuffer(64);
this.offset = 0;
}
ensureBufferWillHandleSize(bytes) {
while (this.buffer.byteLength < this.offset + bytes) {
const newBuffer = new ArrayBuffer(this.buffer.byteLength * 2);
new Uint8Array(newBuffer).set(new Uint8Array(this.buffer));
this.buffer = newBuffer;
}
}
serialize(values) {
this.ensureBufferWillHandleSize(values.length);
new Uint8Array(this.buffer, this.offset).set(values);
this.offset += values.length;
}
serializeWithFunction(fn, bytesLength, value) {
this.ensureBufferWillHandleSize(bytesLength);
const dv = new DataView(this.buffer, this.offset);
fn.apply(dv, [0, value, true]);
this.offset += bytesLength;
}
/**
* Serializes a string. UTF8 string is supported. Serializes the string's bytes length "l" first,
* and then serializes "l" bytes of the string content.
*
* BCS layout for "string": string_length | string_content. string_length is the bytes length of
* the string that is uleb128 encoded. string_length is a u32 integer.
*
* @example
* ```ts
* const serializer = new Serializer();
* serializer.serializeStr("çå∞≠¢õß∂ƒ∫");
* assert(serializer.getBytes() === new Uint8Array([24, 0xc3, 0xa7, 0xc3, 0xa5, 0xe2, 0x88, 0x9e,
* 0xe2, 0x89, 0xa0, 0xc2, 0xa2, 0xc3, 0xb5, 0xc3, 0x9f, 0xe2, 0x88, 0x82, 0xc6, 0x92, 0xe2, 0x88, 0xab]));
* ```
*/
serializeStr(value) {
const textEncoder = new TextEncoder();
this.serializeBytes(textEncoder.encode(value));
}
/**
* Serializes an array of bytes.
*
* BCS layout for "bytes": bytes_length | bytes. bytes_length is the length of the bytes array that is
* uleb128 encoded. bytes_length is a u32 integer.
*/
serializeBytes(value) {
this.serializeU32AsUleb128(value.length);
this.serialize(value);
}
/**
* Serializes an array of bytes with known length. Therefore length doesn't need to be
* serialized to help deserialization. When deserializing, the number of
* bytes to deserialize needs to be passed in.
*/
serializeFixedBytes(value) {
this.serialize(value);
}
/**
* Serializes a boolean value.
*
* BCS layout for "boolean": One byte. "0x01" for True and "0x00" for False.
*/
serializeBool(value) {
if (typeof value !== "boolean") {
throw new Error("Value needs to be a boolean");
}
const byteValue = value ? 1 : 0;
this.serialize(new Uint8Array([byteValue]));
}
serializeU8(value) {
this.serialize(new Uint8Array([value]));
}
serializeU16(value) {
this.serializeWithFunction(DataView.prototype.setUint16, 2, value);
}
serializeU32(value) {
this.serializeWithFunction(DataView.prototype.setUint32, 4, value);
}
serializeU64(value) {
const low = BigInt(value.toString()) & BigInt(MAX_U32_NUMBER);
const high = BigInt(value.toString()) >> BigInt(32);
this.serializeU32(Number(low));
this.serializeU32(Number(high));
}
serializeU128(value) {
const low = BigInt(value.toString()) & MAX_U64_BIG_INT;
const high = BigInt(value.toString()) >> BigInt(64);
this.serializeU64(low);
this.serializeU64(high);
}
serializeU256(value) {
const low = BigInt(value.toString()) & MAX_U128_BIG_INT;
const high = BigInt(value.toString()) >> BigInt(128);
this.serializeU128(low);
this.serializeU128(high);
}
serializeU32AsUleb128(val) {
let value = val;
const valueArray = [];
while (value >>> 7 !== 0) {
valueArray.push(value & 127 | 128);
value >>>= 7;
}
valueArray.push(value);
this.serialize(new Uint8Array(valueArray));
}
/**
* Returns the buffered bytes
*/
getBytes() {
return new Uint8Array(this.buffer).slice(0, this.offset);
}
};
__decorateClass([
checkNumberRange(0, MAX_U8_NUMBER)
], Serializer.prototype, "serializeU8", 1);
__decorateClass([
checkNumberRange(0, MAX_U16_NUMBER)
], Serializer.prototype, "serializeU16", 1);
__decorateClass([
checkNumberRange(0, MAX_U32_NUMBER)
], Serializer.prototype, "serializeU32", 1);
__decorateClass([
checkNumberRange(BigInt(0), MAX_U64_BIG_INT)
], Serializer.prototype, "serializeU64", 1);
__decorateClass([
checkNumberRange(BigInt(0), MAX_U128_BIG_INT)
], Serializer.prototype, "serializeU128", 1);
__decorateClass([
checkNumberRange(BigInt(0), MAX_U256_BIG_INT)
], Serializer.prototype, "serializeU256", 1);
__decorateClass([
checkNumberRange(0, MAX_U32_NUMBER)
], Serializer.prototype, "serializeU32AsUleb128", 1);
function checkNumberRange(minValue, maxValue, message) {
return (target, propertyKey, descriptor) => {
const childFunction = descriptor.value;
descriptor.value = function deco(value) {
const valueBigInt = BigInt(value.toString());
if (valueBigInt > BigInt(maxValue.toString()) || valueBigInt < BigInt(minValue.toString())) {
throw new Error(message || "Value is out of range");
}
childFunction.apply(this, [value]);
};
return descriptor;
};
}
// src/bcs/deserializer.ts
var Deserializer = class {
constructor(data) {
this.buffer = new ArrayBuffer(data.length);
new Uint8Array(this.buffer).set(data, 0);
this.offset = 0;
}
read(length) {
if (this.offset + length > this.buffer.byteLength) {
throw new Error("Reached to the end of buffer");
}
const bytes = this.buffer.slice(this.offset, this.offset + length);
this.offset += length;
return bytes;
}
/**
* Deserializes a string. UTF8 string is supported. Reads the string's bytes length "l" first,
* and then reads "l" bytes of content. Decodes the byte array into a string.
*
* BCS layout for "string": string_length | string_content. string_length is the bytes length of
* the string that is uleb128 encoded. string_length is a u32 integer.
*
* @example
* ```ts
* const deserializer = new Deserializer(new Uint8Array([24, 0xc3, 0xa7, 0xc3, 0xa5, 0xe2, 0x88, 0x9e,
* 0xe2, 0x89, 0xa0, 0xc2, 0xa2, 0xc3, 0xb5, 0xc3, 0x9f, 0xe2, 0x88, 0x82, 0xc6, 0x92, 0xe2, 0x88, 0xab]));
* assert(deserializer.deserializeStr() === "çå∞≠¢õß∂ƒ∫");
* ```
*/
deserializeStr() {
const value = this.deserializeBytes();
const textDecoder = new TextDecoder();
return textDecoder.decode(value);
}
/**
* Deserializes an array of bytes.
*
* BCS layout for "bytes": bytes_length | bytes. bytes_length is the length of the bytes array that is
* uleb128 encoded. bytes_length is a u32 integer.
*/
deserializeBytes() {
const len = this.deserializeUleb128AsU32();
return new Uint8Array(this.read(len));
}
/**
* Deserializes an array of bytes. The number of bytes to read is already known.
*
*/
deserializeFixedBytes(len) {
return new Uint8Array(this.read(len));
}
/**
* Deserializes a boolean value.
*
* BCS layout for "boolean": One byte. "0x01" for True and "0x00" for False.
*/
deserializeBool() {
const bool = new Uint8Array(this.read(1))[0];
if (bool !== 1 && bool !== 0) {
throw new Error("Invalid boolean value");
}
return bool === 1;
}
/**
* Deserializes a uint8 number.
*
* BCS layout for "uint8": One byte. Binary format in little-endian representation.
*/
deserializeU8() {
return new DataView(this.read(1)).getUint8(0);
}
/**
* Deserializes a uint16 number.
*
* BCS layout for "uint16": Two bytes. Binary format in little-endian representation.
* @example
* ```ts
* const deserializer = new Deserializer(new Uint8Array([0x34, 0x12]));
* assert(deserializer.deserializeU16() === 4660);
* ```
*/
deserializeU16() {
return new DataView(this.read(2)).getUint16(0, true);
}
/**
* Deserializes a uint32 number.
*
* BCS layout for "uint32": Four bytes. Binary format in little-endian representation.
* @example
* ```ts
* const deserializer = new Deserializer(new Uint8Array([0x78, 0x56, 0x34, 0x12]));
* assert(deserializer.deserializeU32() === 305419896);
* ```
*/
deserializeU32() {
return new DataView(this.read(4)).getUint32(0, true);
}
/**
* Deserializes a uint64 number.
*
* BCS layout for "uint64": Eight bytes. Binary format in little-endian representation.
* @example
* ```ts
* const deserializer = new Deserializer(new Uint8Array([0x00, 0xEF, 0xCD, 0xAB, 0x78, 0x56, 0x34, 0x12]));
* assert(deserializer.deserializeU64() === 1311768467750121216);
* ```
*/
deserializeU64() {
const low = this.deserializeU32();
const high = this.deserializeU32();
return BigInt(BigInt(high) << BigInt(32) | BigInt(low));
}
/**
* Deserializes a uint128 number.
*
* BCS layout for "uint128": Sixteen bytes. Binary format in little-endian representation.
*/
deserializeU128() {
const low = this.deserializeU64();
const high = this.deserializeU64();
return BigInt(high << BigInt(64) | low);
}
/**
* Deserializes a uint256 number.
*
* BCS layout for "uint256": Thirty-two bytes. Binary format in little-endian representation.
*/
deserializeU256() {
const low = this.deserializeU128();
const high = this.deserializeU128();
return BigInt(high << BigInt(128) | low);
}
/**
* Deserializes a uleb128 encoded uint32 number.
*
* BCS use uleb128 encoding in two cases: (1) lengths of variable-length sequences and (2) tags of enum values
*/
deserializeUleb128AsU32() {
let value = BigInt(0);
let shift = 0;
while (value < MAX_U32_NUMBER) {
const byte = this.deserializeU8();
value |= BigInt(byte & 127) << BigInt(shift);
if ((byte & 128) === 0) {
break;
}
shift += 7;
}
if (value > MAX_U32_NUMBER) {
throw new Error("Overflow while parsing uleb128-encoded uint32 value");
}
return Number(value);
}
};
// src/bcs/helper.ts
function serializeVector(value, serializer) {
serializer.serializeU32AsUleb128(value.length);
value.forEach((item) => {
item.serialize(serializer);
});
}
function serializeVectorWithFunc(value, func) {
const serializer = new Serializer();
serializer.serializeU32AsUleb128(value.length);
const f = serializer[func];
value.forEach((item) => {
f.call(serializer, item);
});
return serializer.getBytes();
}
function deserializeVector(deserializer, cls) {
const length = deserializer.deserializeUleb128AsU32();
const list = [];
for (let i = 0; i < length; i += 1) {
list.push(cls.deserialize(deserializer));
}
return list;
}
function bcsToBytes(value) {
const serializer = new Serializer();
value.serialize(serializer);
return serializer.getBytes();
}
function bcsSerializeUint64(value) {
const serializer = new Serializer();
serializer.serializeU64(value);
return serializer.getBytes();
}
function bcsSerializeU8(value) {
const serializer = new Serializer();
serializer.serializeU8(value);
return serializer.getBytes();
}
function bcsSerializeU16(value) {
const serializer = new Serializer();
serializer.serializeU16(value);
return serializer.getBytes();
}
function bcsSerializeU32(value) {
const serializer = new Serializer();
serializer.serializeU32(value);
return serializer.getBytes();
}
function bcsSerializeU128(value) {
const serializer = new Serializer();
serializer.serializeU128(value);
return serializer.getBytes();
}
function bcsSerializeU256(value) {
const serializer = new Serializer();
serializer.serializeU256(value);
return serializer.getBytes();
}
function bcsSerializeBool(value) {
const serializer = new Serializer();
serializer.serializeBool(value);
return serializer.getBytes();
}
function bcsSerializeStr(value) {
const serializer = new Serializer();
serializer.serializeStr(value);
return serializer.getBytes();
}
function bcsSerializeBytes(value) {
const serializer = new Serializer();
serializer.serializeBytes(value);
return serializer.getBytes();
}
function bcsSerializeFixedBytes(value) {
const serializer = new Serializer();
serializer.serializeFixedBytes(value);
return serializer.getBytes();
}
// src/aptos_types/transaction.ts
var import_sha3 = require("@noble/hashes/sha3");
// src/aptos_types/account_address.ts
var _AccountAddress = class _AccountAddress {
constructor(address) {
if (address.length !== _AccountAddress.LENGTH) {
throw new Error("Expected address of length 32");
}
this.address = address;
}
/**
* Creates AccountAddress from a hex string.
* @param addr Hex string can be with a prefix or without a prefix,
* e.g. '0x1aa' or '1aa'. Hex string will be left padded with 0s if too short.
*/
static fromHex(addr) {
let address = HexString.ensure(addr);
if (address.noPrefix().length % 2 !== 0) {
address = new HexString(`0${address.noPrefix()}`);
}
const addressBytes = address.toUint8Array();
if (addressBytes.length > _AccountAddress.LENGTH) {
throw new Error("Hex string is too long. Address's length is 32 bytes.");
} else if (addressBytes.length === _AccountAddress.LENGTH) {
return new _AccountAddress(addressBytes);
}
const res = new Uint8Array(_AccountAddress.LENGTH);
res.set(addressBytes, _AccountAddress.LENGTH - addressBytes.length);
return new _AccountAddress(res);
}
/**
* Checks if the string is a valid AccountAddress
* @param addr Hex string can be with a prefix or without a prefix,
* e.g. '0x1aa' or '1aa'. Hex string will be left padded with 0s if too short.
*/
static isValid(addr) {
if (addr === "") {
return false;
}
let address = HexString.ensure(addr);
if (address.noPrefix().length % 2 !== 0) {
address = new HexString(`0${address.noPrefix()}`);
}
const addressBytes = address.toUint8Array();
return addressBytes.length <= _AccountAddress.LENGTH;
}
/**
* Return a hex string from account Address.
*/
toHexString() {
return HexString.fromUint8Array(this.address).hex();
}
serialize(serializer) {
serializer.serializeFixedBytes(this.address);
}
static deserialize(deserializer) {
return new _AccountAddress(deserializer.deserializeFixedBytes(_AccountAddress.LENGTH));
}
/**
* Standardizes an address to the format "0x" followed by 64 lowercase hexadecimal digits.
*/
static standardizeAddress(address) {
const lowercaseAddress = address.toLowerCase();
const addressWithoutPrefix = lowercaseAddress.startsWith("0x") ? lowercaseAddress.slice(2) : lowercaseAddress;
const addressWithPadding = addressWithoutPrefix.padStart(64, "0");
return `0x${addressWithPadding}`;
}
};
_AccountAddress.LENGTH = 32;
_AccountAddress.CORE_CODE_ADDRESS = _AccountAddress.fromHex("0x1");
var AccountAddress = _AccountAddress;
// src/aptos_types/ed25519.ts
var _Ed25519PublicKey = class _Ed25519PublicKey {
constructor(value) {
if (value.length !== _Ed25519PublicKey.LENGTH) {
throw new Error(`Ed25519PublicKey length should be ${_Ed25519PublicKey.LENGTH}`);
}
this.value = value;
}
toBytes() {
return this.value;
}
serialize(serializer) {
serializer.serializeBytes(this.value);
}
static deserialize(deserializer) {
const value = deserializer.deserializeBytes();
return new _Ed25519PublicKey(value);
}
};
_Ed25519PublicKey.LENGTH = 32;
var Ed25519PublicKey = _Ed25519PublicKey;
var _Ed25519Signature = class _Ed25519Signature {
constructor(value) {
this.value = value;
if (value.length !== _Ed25519Signature.LENGTH) {
throw new Error(`Ed25519Signature length should be ${_Ed25519Signature.LENGTH}`);
}
}
serialize(serializer) {
serializer.serializeBytes(this.value);
}
static deserialize(deserializer) {
const value = deserializer.deserializeBytes();
return new _Ed25519Signature(value);
}
};
_Ed25519Signature.LENGTH = 64;
var Ed25519Signature = _Ed25519Signature;
// src/aptos_types/multi_ed25519.ts
var MAX_SIGNATURES_SUPPORTED = 32;
var MultiEd25519PublicKey = class _MultiEd25519PublicKey {
/**
* Public key for a K-of-N multisig transaction. A K-of-N multisig transaction means that for such a
* transaction to be executed, at least K out of the N authorized signers have signed the transaction
* and passed the check conducted by the chain.
*
* @see {@link
* https://aptos.dev/guides/creating-a-signed-transaction#multisignature-transactions | Creating a Signed Transaction}
*
* @param public_keys A list of public keys
* @param threshold At least "threshold" signatures must be valid
*/
constructor(public_keys, threshold) {
this.public_keys = public_keys;
this.threshold = threshold;
if (threshold > MAX_SIGNATURES_SUPPORTED) {
throw new Error(`"threshold" cannot be larger than ${MAX_SIGNATURES_SUPPORTED}`);
}
}
/**
* Converts a MultiEd25519PublicKey into bytes with: bytes = p1_bytes | ... | pn_bytes | threshold
*/
toBytes() {
const bytes = new Uint8Array(this.public_keys.length * Ed25519PublicKey.LENGTH + 1);
this.public_keys.forEach((k, i) => {
bytes.set(k.value, i * Ed25519PublicKey.LENGTH);
});
bytes[this.public_keys.length * Ed25519PublicKey.LENGTH] = this.threshold;
return bytes;
}
serialize(serializer) {
serializer.serializeBytes(this.toBytes());
}
static deserialize(deserializer) {
const bytes = deserializer.deserializeBytes();
const threshold = bytes[bytes.length - 1];
const keys = [];
for (let i = 0; i < bytes.length - 1; i += Ed25519PublicKey.LENGTH) {
const begin = i;
keys.push(new Ed25519PublicKey(bytes.subarray(begin, begin + Ed25519PublicKey.LENGTH)));
}
return new _MultiEd25519PublicKey(keys, threshold);
}
};
var _MultiEd25519Signature = class _MultiEd25519Signature {
/**
* Signature for a K-of-N multisig transaction.
*
* @see {@link
* https://aptos.dev/guides/creating-a-signed-transaction#multisignature-transactions | Creating a Signed Transaction}
*
* @param signatures A list of ed25519 signatures
* @param bitmap 4 bytes, at most 32 signatures are supported. If Nth bit value is `1`, the Nth
* signature should be provided in `signatures`. Bits are read from left to right
*/
constructor(signatures, bitmap) {
this.signatures = signatures;
this.bitmap = bitmap;
if (bitmap.length !== _MultiEd25519Signature.BITMAP_LEN) {
throw new Error(`"bitmap" length should be ${_MultiEd25519Signature.BITMAP_LEN}`);
}
}
/**
* Converts a MultiEd25519Signature into bytes with `bytes = s1_bytes | ... | sn_bytes | bitmap`
*/
toBytes() {
const bytes = new Uint8Array(this.signatures.length * Ed25519Signature.LENGTH + _MultiEd25519Signature.BITMAP_LEN);
this.signatures.forEach((k, i) => {
bytes.set(k.value, i * Ed25519Signature.LENGTH);
});
bytes.set(this.bitmap, this.signatures.length * Ed25519Signature.LENGTH);
return bytes;
}
/**
* Helper method to create a bitmap out of the specified bit positions
* @param bits The bitmap positions that should be set. A position starts at index 0.
* Valid position should range between 0 and 31.
* @example
* Here's an example of valid `bits`
* ```
* [0, 2, 31]
* ```
* `[0, 2, 31]` means the 1st, 3rd and 32nd bits should be set in the bitmap.
* The result bitmap should be 0b1010000000000000000000000000001
*
* @returns bitmap that is 32bit long
*/
static createBitmap(bits) {
const firstBitInByte = 128;
const bitmap = new Uint8Array([0, 0, 0, 0]);
const dupCheckSet = /* @__PURE__ */ new Set();
bits.forEach((bit) => {
if (bit >= MAX_SIGNATURES_SUPPORTED) {
throw new Error(`Invalid bit value ${bit}.`);
}
if (dupCheckSet.has(bit)) {
throw new Error("Duplicated bits detected.");
}
dupCheckSet.add(bit);
const byteOffset = Math.floor(bit / 8);
let byte = bitmap[byteOffset];
byte |= firstBitInByte >> bit % 8;
bitmap[byteOffset] = byte;
});
return bitmap;
}
serialize(serializer) {
serializer.serializeBytes(this.toBytes());
}
static deserialize(deserializer) {
const bytes = deserializer.deserializeBytes();
const bitmap = bytes.subarray(bytes.length - 4);
const sigs = [];
for (let i = 0; i < bytes.length - bitmap.length; i += Ed25519Signature.LENGTH) {
const begin = i;
sigs.push(new Ed25519Signature(bytes.subarray(begin, begin + Ed25519Signature.LENGTH)));
}
return new _MultiEd25519Signature(sigs, bitmap);
}
};
_MultiEd25519Signature.BITMAP_LEN = 4;
var MultiEd25519Signature = _MultiEd25519Signature;
// src/aptos_types/authenticator.ts
var TransactionAuthenticator = class {
static deserialize(deserializer) {
const index = deserializer.deserializeUleb128AsU32();
switch (index) {
case 0:
return TransactionAuthenticatorEd25519.load(deserializer);
case 1:
return TransactionAuthenticatorMultiEd25519.load(deserializer);
case 2:
return TransactionAuthenticatorMultiAgent.load(deserializer);
case 3:
return TransactionAuthenticatorFeePayer.load(deserializer);
default:
throw new Error(`Unknown variant index for TransactionAuthenticator: ${index}`);
}
}
};
var TransactionAuthenticatorEd25519 = class _TransactionAuthenticatorEd25519 extends TransactionAuthenticator {
/**
* An authenticator for single signature.
*
* @param public_key Client's public key.
* @param signature Signature of a raw transaction.
* @see {@link https://aptos.dev/guides/creating-a-signed-transaction/ | Creating a Signed Transaction}
* for details about generating a signature.
*/
constructor(public_key, signature) {
super();
this.public_key = public_key;
this.signature = signature;
}
serialize(serializer) {
serializer.serializeU32AsUleb128(0);
this.public_key.serialize(serializer);
this.signature.serialize(serializer);
}
static load(deserializer) {
const public_key = Ed25519PublicKey.deserialize(deserializer);
const signature = Ed25519Signature.deserialize(deserializer);
return new _TransactionAuthenticatorEd25519(public_key, signature);
}
};
var TransactionAuthenticatorMultiEd25519 = class _TransactionAuthenticatorMultiEd25519 extends TransactionAuthenticator {
/**
* An authenticator for multiple signatures.
*
* @param public_key
* @param signature
*
*/
constructor(public_key, signature) {
super();
this.public_key = public_key;
this.signature = signature;
}
serialize(serializer) {
serializer.serializeU32AsUleb128(1);
this.public_key.serialize(serializer);
this.signature.serialize(serializer);
}
static load(deserializer) {
const public_key = MultiEd25519PublicKey.deserialize(deserializer);
const signature = MultiEd25519Signature.deserialize(deserializer);
return new _TransactionAuthenticatorMultiEd25519(public_key, signature);
}
};
var TransactionAuthenticatorMultiAgent = class _TransactionAuthenticatorMultiAgent extends TransactionAuthenticator {
constructor(sender, secondary_signer_addresses, secondary_signers) {
super();
this.sender = sender;
this.secondary_signer_addresses = secondary_signer_addresses;
this.secondary_signers = secondary_signers;
}
serialize(serializer) {
serializer.serializeU32AsUleb128(2);
this.sender.serialize(serializer);
serializeVector(this.secondary_signer_addresses, serializer);
serializeVector(this.secondary_signers, serializer);
}
static load(deserializer) {
const sender = AccountAuthenticator.deserialize(deserializer);
const secondary_signer_addresses = deserializeVector(deserializer, Accoun