@fewcha/aptos
Version:
1,586 lines (1,558 loc) • 242 kB
JavaScript
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
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/account/aptos_account.ts
import nacl2 from "tweetnacl";
import * as bip39 from "@scure/bip39";
import { bytesToHex as bytesToHex2 } from "@noble/hashes/utils";
import { sha256 } from "@noble/hashes/sha256";
import { sha3_256 as sha3Hash3 } from "@noble/hashes/sha3";
// src/utils/hd-key.ts
import nacl from "tweetnacl";
import { hmac } from "@noble/hashes/hmac";
import { sha512 } from "@noble/hashes/sha512";
import { hexToBytes } from "@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 = hmac.create(sha512, HMAC_KEY);
const I = h.update(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 = hmac.create(sha512, chainCode).update(data).digest();
const IL = I.slice(0, 32);
const IR = I.slice(32);
return {
key: IL,
chainCode: IR
};
};
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.14.0";
// src/utils/misc.ts
async function sleep(timeMs) {
return new Promise((resolve2) => {
setTimeout(resolve2, 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
import axios2 from "axios";
// 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/cookieJar.ts
import axios from "axios";
var CookieJar = class {
constructor(jar3 = /* @__PURE__ */ new Map()) {
this.jar = jar3;
}
setCookie(url, cookieStr) {
var _a;
const key = url.origin.toLowerCase();
if (!this.jar.has(key)) {
this.jar.set(key, []);
}
const cookie = CookieJar.parse(cookieStr);
this.jar.set(key, [...((_a = this.jar.get(key)) == null ? void 0 : _a.filter((c) => c.name !== cookie.name)) || [], cookie]);
}
getCookies(url) {
var _a;
const key = url.origin.toLowerCase();
if (!this.jar.get(key)) {
return [];
}
return ((_a = this.jar.get(key)) == null ? void 0 : _a.filter((cookie) => !cookie.expires || cookie.expires > new Date())) || [];
}
static parse(str) {
if (typeof str !== "string") {
throw new Error("argument str must be a string");
}
const parts = str.split(";").map((part) => part.trim());
let cookie;
if (parts.length > 0) {
const [name, value] = parts[0].split("=");
if (!name || !value) {
throw new Error("Invalid cookie");
}
cookie = {
name,
value
};
} else {
throw new Error("Invalid cookie");
}
parts.slice(1).forEach((part) => {
const [name, value] = part.split("=");
if (!name.trim()) {
throw new Error("Invalid cookie");
}
const nameLow = name.toLowerCase();
const val = (value == null ? void 0 : value.charAt(0)) === "'" || (value == null ? void 0 : value.charAt(0)) === '"' ? value == null ? void 0 : value.slice(1, -1) : value;
if (nameLow === "expires") {
cookie.expires = new Date(val);
}
if (nameLow === "path") {
cookie.path = val;
}
if (nameLow === "samesite") {
if (val !== "Lax" && val !== "None" && val !== "Strict") {
throw new Error("Invalid cookie SameSite value");
}
cookie.sameSite = val;
}
if (nameLow === "secure") {
cookie.secure = true;
}
});
return cookie;
}
};
var jar = new CookieJar();
axios.interceptors.response.use((response) => {
if (Array.isArray(response.headers["set-cookie"])) {
response.headers["set-cookie"].forEach((c) => {
jar.setCookie(new URL(response.config.url), c);
});
}
return response;
});
axios.interceptors.request.use(function(config) {
const cookies = jar.getCookies(new URL(config.url));
if ((cookies == null ? void 0 : cookies.length) > 0 && config.headers) {
config.headers.cookie = cookies.map((cookie) => `${cookie.name}=${cookie.value}`).join("; ");
}
return config;
});
// src/client/core.ts
import fetchAdapter from "@vespaiach/axios-fetch-adapter";
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 axiosRequest(url, method, body, contentType, params, overrides) {
var _a;
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 requestConfig = {
headers,
method,
url,
params,
data: body,
adapter: fetchAdapter,
withCredentials: (_a = overrides == null ? void 0 : overrides.WITH_CREDENTIALS) != null ? _a : true
};
try {
return await axios2(requestConfig);
} catch (error) {
const axiosError = error;
if (axiosError.response) {
return axiosError.response;
}
throw error;
}
}
async function aptosRequest(options) {
const { url, endpoint, method, body, contentType, params, overrides } = options;
const fullEndpoint = `${url}/${endpoint != null ? endpoint : ""}`;
const response = await axiosRequest(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 (response.status >= 200 && response.status < 300) {
return result;
}
const errorMessage = errors[response.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"
};
var NetworkToNodeAPI = {
mainnet: "https://fullnode.mainnet.aptoslabs.com/v1",
testnet: "https://fullnode.testnet.aptoslabs.com/v1",
devnet: "https://fullnode.devnet.aptoslabs.com/v1"
};
var NodeAPIToNetwork = {
"https://fullnode.mainnet.aptoslabs.com/v1": "mainnet",
"https://fullnode.testnet.aptoslabs.com/v1": "testnet",
"https://fullnode.devnet.aptoslabs.com/v1": "devnet"
};
var Network = /* @__PURE__ */ ((Network3) => {
Network3["MAINNET"] = "mainnet";
Network3["TESTNET"] = "testnet";
Network3["DEVNET"] = "devnet";
return Network3;
})(Network || {});
// src/utils/hex_string.ts
import { bytesToHex, hexToBytes as hexToBytes2 } from "@noble/hashes/utils";
var HexString = class {
static fromBuffer(buffer) {
return HexString.fromUint8Array(buffer);
}
static fromUint8Array(arr) {
return new HexString(bytesToHex(arr));
}
static ensure(hexString) {
if (typeof hexString === "string") {
return new HexString(hexString);
}
return hexString;
}
constructor(hexString) {
if (hexString.startsWith("0x")) {
this.hexString = hexString;
} else {
this.hexString = `0x${hexString}`;
}
}
hex() {
return this.hexString;
}
noPrefix() {
return this.hexString.slice(2);
}
toString() {
return this.hex();
}
toShortString() {
const trimmed = this.hexString.replace(/^0x0*/, "");
return `0x${trimmed}`;
}
toUint8Array() {
return Uint8Array.from(hexToBytes2(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;
}
serializeStr(value) {
const textEncoder = new TextEncoder();
this.serializeBytes(textEncoder.encode(value));
}
serializeBytes(value) {
this.serializeU32AsUleb128(value.length);
this.serialize(value);
}
serializeFixedBytes(value) {
this.serialize(value);
}
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));
}
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;
}
deserializeStr() {
const value = this.deserializeBytes();
const textDecoder = new TextDecoder();
return textDecoder.decode(value);
}
deserializeBytes() {
const len = this.deserializeUleb128AsU32();
return new Uint8Array(this.read(len));
}
deserializeFixedBytes(len) {
return new Uint8Array(this.read(len));
}
deserializeBool() {
const bool = new Uint8Array(this.read(1))[0];
if (bool !== 1 && bool !== 0) {
throw new Error("Invalid boolean value");
}
return bool === 1;
}
deserializeU8() {
return new DataView(this.read(1)).getUint8(0);
}
deserializeU16() {
return new DataView(this.read(2)).getUint16(0, true);
}
deserializeU32() {
return new DataView(this.read(4)).getUint32(0, true);
}
deserializeU64() {
const low = this.deserializeU32();
const high = this.deserializeU32();
return BigInt(BigInt(high) << BigInt(32) | BigInt(low));
}
deserializeU128() {
const low = this.deserializeU64();
const high = this.deserializeU64();
return BigInt(high << BigInt(64) | low);
}
deserializeU256() {
const low = this.deserializeU128();
const high = this.deserializeU128();
return BigInt(high << BigInt(128) | low);
}
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
import { sha3_256 as sha3Hash } from "@noble/hashes/sha3";
// src/aptos_types/account_address.ts
var _AccountAddress = class {
constructor(address) {
if (address.length !== _AccountAddress.LENGTH) {
throw new Error("Expected address of length 32");
}
this.address = address;
}
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);
}
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;
}
toHexString() {
return HexString.fromUint8Array(this.address).hex();
}
serialize(serializer) {
serializer.serializeFixedBytes(this.address);
}
static deserialize(deserializer) {
return new _AccountAddress(deserializer.deserializeFixedBytes(_AccountAddress.LENGTH));
}
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}`;
}
};
var AccountAddress = _AccountAddress;
AccountAddress.LENGTH = 32;
AccountAddress.CORE_CODE_ADDRESS = _AccountAddress.fromHex("0x1");
// src/aptos_types/ed25519.ts
var _Ed25519PublicKey = class {
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);
}
};
var Ed25519PublicKey = _Ed25519PublicKey;
Ed25519PublicKey.LENGTH = 32;
var _Ed25519Signature = class {
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);
}
};
var Ed25519Signature = _Ed25519Signature;
Ed25519Signature.LENGTH = 64;
// src/aptos_types/multi_ed25519.ts
var MAX_SIGNATURES_SUPPORTED = 32;
var MultiEd25519PublicKey = class {
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}`);
}
}
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 {
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}`);
}
}
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;
}
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);
}
};
var MultiEd25519Signature = _MultiEd25519Signature;
MultiEd25519Signature.BITMAP_LEN = 4;
// 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 extends TransactionAuthenticator {
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 extends TransactionAuthenticator {
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 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, AccountAddress);
const secondary_signers = deserializeVector(deserializer, AccountAuthenticator);
return new TransactionAuthenticatorMultiAgent(sender, secondary_signer_addresses, secondary_signers);
}
};
var TransactionAuthenticatorFeePayer = class extends TransactionAuthenticator {
constructor(sender, secondary_signer_addresses, secondary_signers, fee_payer) {
super();
this.sender = sender;
this.secondary_signer_addresses = secondary_signer_addresses;
this.secondary_signers = secondary_signers;
this.fee_payer = fee_payer;
}
serialize(serializer) {
serializer.serializeU32AsUleb128(3);
this.sender.serialize(serializer);
serializeVector(this.secondary_signer_addresses, serializer);
serializeVector(this.secondary_signers, serializer);
this.fee_payer.address.serialize(serializer);
this.fee_payer.authenticator.serialize(serializer);
}
static load(deserializer) {
const sender = AccountAuthenticator.deserialize(deserializer);
const secondary_signer_addresses = deserializeVector(deserializer, AccountAddress);
const secondary_signers = deserializeVector(deserializer, AccountAuthenticator);
const address = AccountAddress.deserialize(deserializer);
const authenticator = AccountAuthenticator.deserialize(deserializer);
const fee_payer = { address, authenticator };
return new TransactionAuthenticatorFeePayer(sender, secondary_signer_addresses, secondary_signers, fee_payer);
}
};
var AccountAuthenticator = class {
static deserialize(deserializer) {
const index = deserializer.deserializeUleb128AsU32();
switch (index) {
case 0:
return AccountAuthenticatorEd25519.load(deserializer);
case 1:
return AccountAuthenticatorMultiEd25519.load(deserializer);
default:
throw new Error(`Unknown variant index for AccountAuthenticator: ${index}`);
}
}
};
var AccountAuthenticatorEd25519 = class extends AccountAuthenticator {
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 AccountAuthenticatorEd25519(public_key, signature);
}
};
var AccountAuthenticatorMultiEd25519 = class extends AccountAuthenticator {
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 AccountAuthenticatorMultiEd25519(public_key, signature);
}
};
// src/aptos_types/identifier.ts
var Identifier = class {
constructor(value) {
this.value = value;
}
serialize(serializer) {
serializer.serializeStr(this.value);
}
static deserialize(deserializer) {
const value = deserializer.deserializeStr();
return new Identifier(value);
}
};
// src/aptos_types/type_tag.ts
var TypeTag = class {
static deserialize(deserializer) {
const index = deserializer.deserializeUleb128AsU32();
switch (index) {
case 0:
return TypeTagBool.load(deserializer);
case 1:
return TypeTagU8.load(deserializer);
case 2:
return TypeTagU64.load(deserializer);
case 3:
return TypeTagU128.load(deserializer);
case 4:
return TypeTagAddress.load(deserializer);
case 5:
return TypeTagSigner.load(deserializer);
case 6:
return TypeTagVector.load(deserializer);
case 7:
return TypeTagStruct.load(deserializer);
case 8:
return TypeTagU16.load(deserializer);
case 9:
return TypeTagU32.load(deserializer);
case 10:
return TypeTagU256.load(deserializer);
default:
throw new Error(`Unknown variant index for TypeTag: ${index}`);
}
}
};
var TypeTagBool = class extends TypeTag {
serialize(serializer) {
serializer.serializeU32AsUleb128(0);
}
static load(_deserializer) {
return new TypeTagBool();
}
};
var TypeTagU8 = class extends TypeTag {
serialize(serializer) {
serializer.serializeU32AsUleb128(1);
}
static load(_deserializer) {
return new TypeTagU8();
}
};
var TypeTagU16 = class extends TypeTag {
serialize(serializer) {
serializer.serializeU32AsUleb128(8);
}
static load(_deserializer) {
return new TypeTagU16();
}
};
var TypeTagU32 = class extends TypeTag {
serialize(serializer) {
serializer.serializeU32AsUleb128(9);
}
static load(_deserializer) {
return new TypeTagU32();
}
};
var TypeTagU64 = class extends TypeTag {
serialize(serializer) {
serializer.serializeU32AsUleb128(2);
}
static load(_deserializer) {
return new TypeTagU64();
}
};
var TypeTagU128 = class extends TypeTag {
serialize(serializer) {
serializer.serializeU32AsUleb128(3);
}
static load(_deserializer) {
return new TypeTagU128();
}
};
var TypeTagU256 = class extends TypeTag {
serialize(serializer) {
serializer.serializeU32AsUleb128(10);
}
static load(_deserializer) {
return new TypeTagU256();
}
};
var TypeTagAddress = class extends TypeTag {
serialize(serializer) {
serializer.serializeU32AsUleb128(4);
}
static load(_deserializer) {
return new TypeTagAddress();
}
};
var TypeTagSigner = class extends TypeTag {
serialize(serializer) {
serializer.serializeU32AsUleb128(5);
}
static load(_deserializer) {
return new TypeTagSigner();
}
};
var TypeTagVector = class extends TypeTag {
constructor(value) {
super();
this.value = value;
}
serialize(serializer) {
serializer.serializeU32AsUleb128(6);
this.value.serialize(serializer);
}
static load(deserializer) {
const value = TypeTag.deserialize(deserializer);
return new TypeTagVector(value);
}
};
var TypeTagStruct = class extends TypeTag {
constructor(value) {
super();
this.value = value;
}
serialize(serializer) {
serializer.serializeU32AsUleb128(7);
this.value.serialize(serializer);
}
static load(deserializer) {
const value = StructTag.deserialize(deserializer);
return new TypeTagStruct(value);
}
isStringTypeTag() {
if (this.value.module_name.value === "string" && this.value.name.value === "String" && this.value.address.toHexString() === AccountAddress.CORE_CODE_ADDRESS.toHexString()) {
return true;
}
return false;
}
};
var StructTag = class {
constructor(address, module_name, name, type_args) {
this.address = address;
this.module_name = module_name;
this.name = name;
this.type_args = type_args;
}
static fromString(structTag) {
const typeTagStruct = new TypeTagParser(structTag).parseTypeTag();
return new StructTag(
typeTagStruct.value.address,
typeTagStruct.value.module_name,
typeTagStruct.value.name,
typeTagStruct.value.type_args
);
}
serialize(serializer) {
this.address.serialize(serializer);
this.module_name.serialize(serializer);
this.name.serialize(serializer);
serializeVector(this.type_args, serializer);
}
static deserialize(deserializer) {
const address = AccountAddress.deserialize(deserializer);
const moduleName = Identifier.deserialize(deserializer);
const name = Identifier.deserialize(deserializer);
const typeArgs = deserializeVector(deserializer, TypeTag);
return new StructTag(address, moduleName, name, typeArgs);
}
};
var stringStructTag = new StructTag(
AccountAddress.fromHex("0x1"),
new Identifier("string"),
new Identifier("String"),
[]
);
function optionStructTag(typeArg) {
return new StructTag(AccountAddress.fromHex("0x1"), new Identifier("option"), new Identifier("Option"), [typeArg]);
}
function objectStructTag(typeArg) {
return new StructTag(AccountAddress.fromHex("0x1"), new Identifier("object"), new Identifier("Object"), [typeArg]);
}
function bail(message) {
throw new TypeTagParserError(message);
}
function isWhiteSpace(c) {
if (c.match(/\s/)) {
return true;
}
return false;
}
function isValidAlphabetic(c) {
if (c.match(/[_A-Za-z0-9]/g)) {
return true;
}
return false;
}
function isGeneric(c) {
if (c.match(/T\d+/g)) {
return true;
}
return false;
}
function nextToken(tagStr, pos) {
const c = tagStr[pos];
if (c === ":") {
if (tagStr.slice(pos, pos + 2) === "::") {
return [["COLON", "::"], 2];
}
bail("Unrecognized token.");
} else if (c === "<") {
return [["LT", "<"], 1];
} else if (c === ">") {
return [["GT", ">"], 1];
} else if (c === ",") {
return [["COMMA", ","], 1];
} else if (isWhiteSpace(c)) {
let res = "";
for (let i = pos; i < tagStr.length; i += 1) {
const char = tagStr[i];
if (isWhiteSpace(char)) {
res = `${res}${char}`;
} else {
break;
}
}
return [["SPACE", res], res.length];
} else if (isValidAlphabetic(c)) {
let res = "";
for (let i = pos; i < tagStr.length; i += 1) {
const char = tagStr[i];
if (isValidAlphabetic(char)) {
res = `${res}${char}`;
} else {
break;
}
}
if (isGeneric(res)) {
return [["GENERIC", res], res.length];
}
return [["IDENT", res], res.length];
}
throw new Error("Unrecognized token.");
}
function tokenize(tagStr) {
let pos = 0;
const tokens = [];
while (pos < tagStr.length) {
const [token, size] = nextToken(tagStr, pos);
if (token[0] !== "SPACE") {
tokens.push(token);
}
pos += size;
}
return tokens;
}
var TypeTagParser = class {
constructor(tagStr, typeTags) {
this.typeTags = [];
this.tokens = tokenize(tagStr);
this.typeTags = typeTags || [];
}
consume(targetToken) {
const token = this.tokens.shift();
if (!token || token[1] !== targetToken) {
bail("Invalid type tag.");
}
}
consumeWholeGeneric() {
this.consume("<");
while (this.tokens[0][1] !== ">") {
if (this.tokens[0][1] === "<") {
this.consumeWholeGeneric();
}
this.tokens.shift();
}
this.consume(">");
}
parseCommaList(endToken, allowTraillingComma) {
const res = [];
if (this.tokens.length <= 0) {
bail("Invalid type tag.");
}
while (this.tokens[0][1] !== endToken) {
res.push(this.parseTypeTag());
if (this.tokens.length > 0 && this.tokens[0][1] === endToken) {
break;
}
this.consume(",");
if (this.tokens.length > 0 && this.tokens[0][1] === endToken && allowTraillingComma) {
break;
}
if (this.tokens.length <= 0) {
bail("Invalid type tag.");
}
}
return res;
}
parseTypeTag() {
if (this.tokens.length === 0) {
bail("Invalid type tag.");
}
const [tokenTy, tokenVal] = this.tokens.shift();
if (tokenVal === "u8") {
return new TypeTagU8();
}
if (tokenVal === "u16") {
return new TypeTagU16();
}
if (tokenVal === "u32") {
return new TypeTagU32();
}
if (tokenVal === "u64") {
return new TypeTagU64();
}
if (tokenVal === "u128") {
return new TypeTagU128();
}
if (tokenVal === "u256") {
return new TypeTagU256();
}
if (tokenVal === "bool") {
return new TypeTagBool();
}
if (tokenVal === "address") {
return new TypeTagAddress();
}
if (tokenVal === "vector") {
this.consume("<");
const res = this.parseTypeTag();
this.consume(">");
return new TypeTagVector(res);
}
if (tokenVal === "string") {
return stringStructTag;
}
if (tokenTy === "IDENT" && (tokenVal.startsWith("0x") || tokenVal.startsWith("0X"))) {
const address = AccountAddress.fromHex(tokenVal);
this.consume("::");
const [moduleTokenTy, module] = this.tokens.shift();
if (moduleTokenTy !== "IDENT") {
bail("Invalid type tag.");
}
this.consume("::");
const [nameTokenTy, name] = this.tokens.shift();
if (nameTokenTy !== "IDENT") {
bail("Invalid type tag.");
}
if (AccountAddress.CORE_CODE_ADDRESS.toHexString() === address.toHexString() && module === "object" && name === "Object") {
this.consumeWholeGeneric();
return new TypeTagAddress();
}
let tyTags = [];
if (this.tokens.length > 0 && this.tokens[0][1] === "<") {
this.consume("<");
tyTags = this.parseCommaList(">", true);
this.consume(">");
}
const structTag = new StructTag(address, new Identifier(module), new Identifier(name), tyTags);
return new TypeTagStruct(structTag);
}
if (tokenTy === "GENERIC") {
if (this.typeTags.length === 0) {
bail("Can't convert generic type since no typeTags were specified.");
}
const idx = parseInt(tokenVal.substring(1), 10);
return new TypeTagParser(this.typeTags[idx]).parseTypeTag();
}
throw new Error("Invalid type tag.");
}
};
var TypeTagParserError = class extends Error {
constructor(message) {
super(message);
this.name = "TypeTagParserError";
}
};
// src/aptos_types/transaction.ts
var RawTransaction = class {
constructor(sender, sequence_number, payload, max_gas_amount, gas_unit_price, expiration_timestamp_secs, chain_id) {
this.sender = sender;
this.sequence_number = sequence_number;
this.payload = payload;
this.max_gas_amount = max_gas_amount;
this.gas_unit_price = gas_unit_price;
this.expiration_timestamp_secs = expiration_timestamp_secs;
this.chain_id = chain_id;
}
serialize(serializer) {
this.sender.serialize(serializer);
serializer.serializeU64(this.sequence_number);
this.payload.serialize(serializer);
serializer.serializeU64(this.max_gas_amount);
serializer.serializeU64(this.gas_unit_price);
serializer.serializeU64(this.expiration_timestamp_secs);
this.chain_id.serialize(serializer);
}
static deserialize(deserializer) {
const sender = AccountAddress.deserialize(deserializer);
const sequence_number = deserializer.deserializeU64();
const payload = TransactionPayload.deserialize(deserializer);
const max_gas_amount = deserializer.deserializeU64();
const gas_unit_price = deserializer.deserializeU64();
const expiration_timestamp_secs = deserializer.deserializeU64();
const chain_id = ChainId.deserialize(deserializer);
return new RawTransact