diff --git a/ecosystem/typescript/sdk_v2/src/transactions/authenticator/account.ts b/ecosystem/typescript/sdk_v2/src/transactions/authenticator/account.ts index c6ac8c6d27065..6901f95e36119 100644 --- a/ecosystem/typescript/sdk_v2/src/transactions/authenticator/account.ts +++ b/ecosystem/typescript/sdk_v2/src/transactions/authenticator/account.ts @@ -3,7 +3,7 @@ import { Serializer, Deserializer, Serializable } from "../../bcs"; import { Ed25519PublicKey, Ed25519Signature } from "../../crypto/ed25519"; import { MultiEd25519PublicKey, MultiEd25519Signature } from "../../crypto/multi_ed25519"; -import { RustEnumAccountAuthenticatorVariant } from "../../types"; +import { AccountAuthenticatorVariant } from "../../types"; export abstract class AccountAuthenticator extends Serializable { abstract serialize(serializer: Serializer): void; @@ -11,9 +11,9 @@ export abstract class AccountAuthenticator extends Serializable { static deserialize(deserializer: Deserializer): AccountAuthenticator { const index = deserializer.deserializeUleb128AsU32(); switch (index) { - case RustEnumAccountAuthenticatorVariant.AccountAuthenticatorEd25519: + case AccountAuthenticatorVariant.AccountAuthenticatorEd25519: return AccountAuthenticatorEd25519.load(deserializer); - case RustEnumAccountAuthenticatorVariant.AccountAuthenticatorMultiEd25519: + case AccountAuthenticatorVariant.AccountAuthenticatorMultiEd25519: return AccountAuthenticatorMultiEd25519.load(deserializer); default: throw new Error(`Unknown variant index for AccountAuthenticator: ${index}`); @@ -40,7 +40,7 @@ export class AccountAuthenticatorEd25519 extends AccountAuthenticator { * */ serialize(serializer: Serializer): void { - serializer.serializeU32AsUleb128(RustEnumAccountAuthenticatorVariant.AccountAuthenticatorEd25519); + serializer.serializeU32AsUleb128(AccountAuthenticatorVariant.AccountAuthenticatorEd25519); this.public_key.serialize(serializer); this.signature.serialize(serializer); } @@ -71,7 +71,7 @@ export class AccountAuthenticatorMultiEd25519 extends AccountAuthenticator { } serialize(serializer: Serializer): void { - serializer.serializeU32AsUleb128(RustEnumAccountAuthenticatorVariant.AccountAuthenticatorMultiEd25519); + serializer.serializeU32AsUleb128(AccountAuthenticatorVariant.AccountAuthenticatorMultiEd25519); this.public_key.serialize(serializer); this.signature.serialize(serializer); } diff --git a/ecosystem/typescript/sdk_v2/src/transactions/authenticator/transaction.ts b/ecosystem/typescript/sdk_v2/src/transactions/authenticator/transaction.ts index d15eda877ffd5..1629dd8526fde 100644 --- a/ecosystem/typescript/sdk_v2/src/transactions/authenticator/transaction.ts +++ b/ecosystem/typescript/sdk_v2/src/transactions/authenticator/transaction.ts @@ -4,7 +4,7 @@ import { Deserializer, Serializer } from "../../bcs"; import { AccountAddress } from "../../core"; import { Ed25519PublicKey, Ed25519Signature } from "../../crypto/ed25519"; import { MultiEd25519PublicKey, MultiEd25519Signature } from "../../crypto/multi_ed25519"; -import { RustEnumTransactionAuthenticatorVariant } from "../../types"; +import { TransactionAuthenticatorVariant } from "../../types"; import { AccountAuthenticator } from "./account"; export abstract class TransactionAuthenticator { @@ -13,13 +13,13 @@ export abstract class TransactionAuthenticator { static deserialize(deserializer: Deserializer): TransactionAuthenticator { const index = deserializer.deserializeUleb128AsU32(); switch (index) { - case RustEnumTransactionAuthenticatorVariant.TransactionAuthenticatorEd25519: + case TransactionAuthenticatorVariant.TransactionAuthenticatorEd25519: return TransactionAuthenticatorEd25519.load(deserializer); - case RustEnumTransactionAuthenticatorVariant.TransactionAuthenticatorMultiEd25519: + case TransactionAuthenticatorVariant.TransactionAuthenticatorMultiEd25519: return TransactionAuthenticatorMultiEd25519.load(deserializer); - case RustEnumTransactionAuthenticatorVariant.TransactionAuthenticatorMultiAgent: + case TransactionAuthenticatorVariant.TransactionAuthenticatorMultiAgent: return TransactionAuthenticatorMultiAgent.load(deserializer); - case RustEnumTransactionAuthenticatorVariant.TransactionAuthenticatorFeePayer: + case TransactionAuthenticatorVariant.TransactionAuthenticatorFeePayer: return TransactionAuthenticatorFeePayer.load(deserializer); default: throw new Error(`Unknown variant index for TransactionAuthenticator: ${index}`); @@ -47,7 +47,7 @@ export class TransactionAuthenticatorEd25519 extends TransactionAuthenticator { } serialize(serializer: Serializer): void { - serializer.serializeU32AsUleb128(RustEnumTransactionAuthenticatorVariant.TransactionAuthenticatorEd25519); + serializer.serializeU32AsUleb128(TransactionAuthenticatorVariant.TransactionAuthenticatorEd25519); this.public_key.serialize(serializer); this.signature.serialize(serializer); } @@ -78,7 +78,7 @@ export class TransactionAuthenticatorMultiEd25519 extends TransactionAuthenticat } serialize(serializer: Serializer): void { - serializer.serializeU32AsUleb128(RustEnumTransactionAuthenticatorVariant.TransactionAuthenticatorMultiEd25519); + serializer.serializeU32AsUleb128(TransactionAuthenticatorVariant.TransactionAuthenticatorMultiEd25519); this.public_key.serialize(serializer); this.signature.serialize(serializer); } @@ -117,7 +117,7 @@ export class TransactionAuthenticatorMultiAgent extends TransactionAuthenticator } serialize(serializer: Serializer): void { - serializer.serializeU32AsUleb128(RustEnumTransactionAuthenticatorVariant.TransactionAuthenticatorMultiAgent); + serializer.serializeU32AsUleb128(TransactionAuthenticatorVariant.TransactionAuthenticatorMultiAgent); this.sender.serialize(serializer); serializer.serializeVector(this.secondary_signer_addresses); serializer.serializeVector(this.secondary_signers); @@ -163,7 +163,7 @@ export class TransactionAuthenticatorFeePayer extends TransactionAuthenticator { } serialize(serializer: Serializer): void { - serializer.serializeU32AsUleb128(RustEnumTransactionAuthenticatorVariant.TransactionAuthenticatorFeePayer); + serializer.serializeU32AsUleb128(TransactionAuthenticatorVariant.TransactionAuthenticatorFeePayer); this.sender.serialize(serializer); serializer.serializeVector(this.secondary_signer_addresses); serializer.serializeVector(this.secondary_signers); diff --git a/ecosystem/typescript/sdk_v2/src/transactions/types/index.ts b/ecosystem/typescript/sdk_v2/src/transactions/types/index.ts index 1f347d0029e2e..6d5c4a82dd67b 100644 --- a/ecosystem/typescript/sdk_v2/src/transactions/types/index.ts +++ b/ecosystem/typescript/sdk_v2/src/transactions/types/index.ts @@ -1,6 +1,6 @@ export * from "./chainId"; export * from "./rawTransaction"; -export * from "./transactionArguments"; +export * from "./scriptTransactionArguments"; export * from "./transactionPayload"; export * from "./moduleId"; export * from "./identifier"; diff --git a/ecosystem/typescript/sdk_v2/src/transactions/types/rawTransaction.ts b/ecosystem/typescript/sdk_v2/src/transactions/types/rawTransaction.ts index 2a15f9a675a7c..9036bf2ada7c7 100644 --- a/ecosystem/typescript/sdk_v2/src/transactions/types/rawTransaction.ts +++ b/ecosystem/typescript/sdk_v2/src/transactions/types/rawTransaction.ts @@ -2,9 +2,8 @@ import { Deserializer, Serializer } from "../../bcs"; import { AccountAddress } from "../../core"; -import { RustEnumTransactionVariants } from "../../types"; +import { TransactionVariants } from "../../types"; import { ChainId } from "./chainId"; -import { TransactionArgument } from "./transactionArguments"; import { TransactionPayload } from "./transactionPayload"; /** @@ -104,9 +103,9 @@ export abstract class RawTransactionWithData { // undex enum variant const index = deserializer.deserializeUleb128AsU32(); switch (index) { - case RustEnumTransactionVariants.MultiAgentTransaction: + case TransactionVariants.MultiAgentTransaction: return MultiAgentRawTransaction.load(deserializer); - case RustEnumTransactionVariants.FeePayerTransaction: + case TransactionVariants.FeePayerTransaction: return FeePayerRawTransaction.load(deserializer); default: throw new Error(`Unknown variant index for RawTransactionWithData: ${index}`); @@ -135,9 +134,9 @@ export class MultiAgentRawTransaction extends RawTransactionWithData { } serialize(serializer: Serializer): void { - serializer.serializeU32AsUleb128(RustEnumTransactionVariants.MultiAgentTransaction); + serializer.serializeU32AsUleb128(TransactionVariants.MultiAgentTransaction); this.raw_txn.serialize(serializer); - serializer.serializeVector(this.secondary_signer_addresses); + serializer.serializeVector(this.secondary_signer_addresses); } static load(deserializer: Deserializer): MultiAgentRawTransaction { @@ -179,9 +178,9 @@ export class FeePayerRawTransaction extends RawTransactionWithData { } serialize(serializer: Serializer): void { - serializer.serializeU32AsUleb128(RustEnumTransactionVariants.FeePayerTransaction); + serializer.serializeU32AsUleb128(TransactionVariants.FeePayerTransaction); this.raw_txn.serialize(serializer); - serializer.serializeVector(this.secondary_signer_addresses); + serializer.serializeVector(this.secondary_signer_addresses); this.fee_payer_address.serialize(serializer); } diff --git a/ecosystem/typescript/sdk_v2/src/transactions/types/scriptTransactionArguments.ts b/ecosystem/typescript/sdk_v2/src/transactions/types/scriptTransactionArguments.ts new file mode 100644 index 0000000000000..8a41e4a87924d --- /dev/null +++ b/ecosystem/typescript/sdk_v2/src/transactions/types/scriptTransactionArguments.ts @@ -0,0 +1,214 @@ +import { Serializer, Deserializer, Serializable } from "../../bcs"; +import { AccountAddress } from "../../core"; +import { ScriptTransactionArgumentVariants } from "../../types"; + +/** + * Representation of a Script Transaction Argument that can be serialized and deserialized + */ +export abstract class ScriptTransactionArgument extends Serializable { + /** + * Serialize a Script Transaction Argument + */ + abstract serialize(serializer: Serializer): void; + + /** + * Deserialize a Script Transaction Argument + */ + static deserialize(deserializer: Deserializer): ScriptTransactionArgument { + // index enum variant + const index = deserializer.deserializeUleb128AsU32(); + switch (index) { + case ScriptTransactionArgumentVariants.ScriptTransactionArgumentU8: + return ScriptTransactionArgumentU8.load(deserializer); + case ScriptTransactionArgumentVariants.ScriptTransactionArgumentU64: + return ScriptTransactionArgumentU64.load(deserializer); + case ScriptTransactionArgumentVariants.ScriptTransactionArgumentU128: + return ScriptTransactionArgumentU128.load(deserializer); + case ScriptTransactionArgumentVariants.ScriptTransactionArgumentAddress: + return ScriptTransactionArgumentAddress.load(deserializer); + case ScriptTransactionArgumentVariants.ScriptTransactionArgumentU8Vector: + return ScriptTransactionArgumentU8Vector.load(deserializer); + case ScriptTransactionArgumentVariants.ScriptTransactionArgumentBool: + return ScriptTransactionArgumentBool.load(deserializer); + case ScriptTransactionArgumentVariants.ScriptTransactionArgumentU16: + return ScriptTransactionArgumentU16.load(deserializer); + case ScriptTransactionArgumentVariants.ScriptTransactionArgumentU32: + return ScriptTransactionArgumentU32.load(deserializer); + case ScriptTransactionArgumentVariants.ScriptTransactionArgumentU256: + return ScriptTransactionArgumentU256.load(deserializer); + default: + throw new Error(`Unknown variant index for ScriptTransactionArgument: ${index}`); + } + } +} + +export class ScriptTransactionArgumentU8 extends ScriptTransactionArgument { + public readonly value: number; + + constructor(value: number) { + super(); + this.value = value; + } + + serialize(serializer: Serializer): void { + serializer.serializeU32AsUleb128(ScriptTransactionArgumentVariants.ScriptTransactionArgumentU8); + serializer.serializeU8(this.value); + } + + static load(deserializer: Deserializer): ScriptTransactionArgumentU8 { + const value = deserializer.deserializeU8(); + return new ScriptTransactionArgumentU8(value); + } +} + +export class ScriptTransactionArgumentU16 extends ScriptTransactionArgument { + public readonly value: number; + + constructor(value: number) { + super(); + this.value = value; + } + + serialize(serializer: Serializer): void { + serializer.serializeU32AsUleb128(ScriptTransactionArgumentVariants.ScriptTransactionArgumentU16); + serializer.serializeU16(this.value); + } + + static load(deserializer: Deserializer): ScriptTransactionArgumentU16 { + const value = deserializer.deserializeU16(); + return new ScriptTransactionArgumentU16(value); + } +} + +export class ScriptTransactionArgumentU32 extends ScriptTransactionArgument { + public readonly value: number; + + constructor(value: number) { + super(); + this.value = value; + } + + serialize(serializer: Serializer): void { + serializer.serializeU32AsUleb128(ScriptTransactionArgumentVariants.ScriptTransactionArgumentU32); + serializer.serializeU32(this.value); + } + + static load(deserializer: Deserializer): ScriptTransactionArgumentU32 { + const value = deserializer.deserializeU32(); + return new ScriptTransactionArgumentU32(value); + } +} + +export class ScriptTransactionArgumentU64 extends ScriptTransactionArgument { + public readonly value: bigint; + + constructor(value: bigint) { + super(); + this.value = value; + } + + serialize(serializer: Serializer): void { + serializer.serializeU32AsUleb128(ScriptTransactionArgumentVariants.ScriptTransactionArgumentU64); + serializer.serializeU64(this.value); + } + + static load(deserializer: Deserializer): ScriptTransactionArgumentU64 { + const value = deserializer.deserializeU64(); + return new ScriptTransactionArgumentU64(value); + } +} + +export class ScriptTransactionArgumentU128 extends ScriptTransactionArgument { + public readonly value: bigint; + + constructor(value: bigint) { + super(); + this.value = value; + } + + serialize(serializer: Serializer): void { + serializer.serializeU32AsUleb128(ScriptTransactionArgumentVariants.ScriptTransactionArgumentU128); + serializer.serializeU128(this.value); + } + + static load(deserializer: Deserializer): ScriptTransactionArgumentU128 { + const value = deserializer.deserializeU128(); + return new ScriptTransactionArgumentU128(value); + } +} + +export class ScriptTransactionArgumentU256 extends ScriptTransactionArgument { + public readonly value: bigint; + + constructor(value: bigint) { + super(); + this.value = value; + } + + serialize(serializer: Serializer): void { + serializer.serializeU32AsUleb128(ScriptTransactionArgumentVariants.ScriptTransactionArgumentU256); + serializer.serializeU256(this.value); + } + + static load(deserializer: Deserializer): ScriptTransactionArgumentU256 { + const value = deserializer.deserializeU256(); + return new ScriptTransactionArgumentU256(value); + } +} + +export class ScriptTransactionArgumentAddress extends ScriptTransactionArgument { + public readonly value: AccountAddress; + + constructor(value: AccountAddress) { + super(); + this.value = value; + } + + serialize(serializer: Serializer): void { + serializer.serializeU32AsUleb128(ScriptTransactionArgumentVariants.ScriptTransactionArgumentAddress); + this.value.serialize(serializer); + } + + static load(deserializer: Deserializer): ScriptTransactionArgumentAddress { + const value = AccountAddress.deserialize(deserializer); + return new ScriptTransactionArgumentAddress(value); + } +} + +export class ScriptTransactionArgumentU8Vector extends ScriptTransactionArgument { + public readonly value: Uint8Array; + + constructor(value: Uint8Array) { + super(); + this.value = value; + } + + serialize(serializer: Serializer): void { + serializer.serializeU32AsUleb128(ScriptTransactionArgumentVariants.ScriptTransactionArgumentU8Vector); + serializer.serializeBytes(this.value); + } + + static load(deserializer: Deserializer): ScriptTransactionArgumentU8Vector { + const value = deserializer.deserializeBytes(); + return new ScriptTransactionArgumentU8Vector(value); + } +} + +export class ScriptTransactionArgumentBool extends ScriptTransactionArgument { + public readonly value: boolean; + + constructor(value: boolean) { + super(); + this.value = value; + } + + serialize(serializer: Serializer): void { + serializer.serializeU32AsUleb128(ScriptTransactionArgumentVariants.ScriptTransactionArgumentBool); + serializer.serializeBool(this.value); + } + + static load(deserializer: Deserializer): ScriptTransactionArgumentBool { + const value = deserializer.deserializeBool(); + return new ScriptTransactionArgumentBool(value); + } +} diff --git a/ecosystem/typescript/sdk_v2/src/transactions/types/transactionArguments.ts b/ecosystem/typescript/sdk_v2/src/transactions/types/transactionArguments.ts deleted file mode 100644 index 9b0529701edf7..0000000000000 --- a/ecosystem/typescript/sdk_v2/src/transactions/types/transactionArguments.ts +++ /dev/null @@ -1,214 +0,0 @@ -import { Serializer, Deserializer, Serializable } from "../../bcs"; -import { AccountAddress } from "../../core"; -import { RustEnumTransactionArgumentVariants } from "../../types"; - -/** - * Representation of a Transaction Argument that can serialized and deserialized - */ -export abstract class TransactionArgument extends Serializable { - /** - * Serialize a Transaction Argument - */ - abstract serialize(serializer: Serializer): void; - - /** - * Deserialize a Transaction Argument - */ - static deserialize(deserializer: Deserializer): TransactionArgument { - // index enum variant - const index = deserializer.deserializeUleb128AsU32(); - switch (index) { - case RustEnumTransactionArgumentVariants.TransactionArgumentU8: - return TransactionArgumentU8.load(deserializer); - case RustEnumTransactionArgumentVariants.TransactionArgumentU64: - return TransactionArgumentU64.load(deserializer); - case RustEnumTransactionArgumentVariants.TransactionArgumentU128: - return TransactionArgumentU128.load(deserializer); - case RustEnumTransactionArgumentVariants.TransactionArgumentAddress: - return TransactionArgumentAddress.load(deserializer); - case RustEnumTransactionArgumentVariants.TransactionArgumentU8Vector: - return TransactionArgumentU8Vector.load(deserializer); - case RustEnumTransactionArgumentVariants.TransactionArgumentBool: - return TransactionArgumentBool.load(deserializer); - case RustEnumTransactionArgumentVariants.TransactionArgumentU16: - return TransactionArgumentU16.load(deserializer); - case RustEnumTransactionArgumentVariants.TransactionArgumentU32: - return TransactionArgumentU32.load(deserializer); - case RustEnumTransactionArgumentVariants.TransactionArgumentU256: - return TransactionArgumentU256.load(deserializer); - default: - throw new Error(`Unknown variant index for TransactionArgument: ${index}`); - } - } -} - -export class TransactionArgumentU8 extends TransactionArgument { - public readonly value: number; - - constructor(value: number) { - super(); - this.value = value; - } - - serialize(serializer: Serializer): void { - serializer.serializeU32AsUleb128(RustEnumTransactionArgumentVariants.TransactionArgumentU8); - serializer.serializeU8(this.value); - } - - static load(deserializer: Deserializer): TransactionArgumentU8 { - const value = deserializer.deserializeU8(); - return new TransactionArgumentU8(value); - } -} - -export class TransactionArgumentU16 extends TransactionArgument { - public readonly value: number; - - constructor(value: number) { - super(); - this.value = value; - } - - serialize(serializer: Serializer): void { - serializer.serializeU32AsUleb128(RustEnumTransactionArgumentVariants.TransactionArgumentU16); - serializer.serializeU16(this.value); - } - - static load(deserializer: Deserializer): TransactionArgumentU16 { - const value = deserializer.deserializeU16(); - return new TransactionArgumentU16(value); - } -} - -export class TransactionArgumentU32 extends TransactionArgument { - public readonly value: number; - - constructor(value: number) { - super(); - this.value = value; - } - - serialize(serializer: Serializer): void { - serializer.serializeU32AsUleb128(RustEnumTransactionArgumentVariants.TransactionArgumentU32); - serializer.serializeU32(this.value); - } - - static load(deserializer: Deserializer): TransactionArgumentU32 { - const value = deserializer.deserializeU32(); - return new TransactionArgumentU32(value); - } -} - -export class TransactionArgumentU64 extends TransactionArgument { - public readonly value: bigint; - - constructor(value: bigint) { - super(); - this.value = value; - } - - serialize(serializer: Serializer): void { - serializer.serializeU32AsUleb128(RustEnumTransactionArgumentVariants.TransactionArgumentU64); - serializer.serializeU64(this.value); - } - - static load(deserializer: Deserializer): TransactionArgumentU64 { - const value = deserializer.deserializeU64(); - return new TransactionArgumentU64(value); - } -} - -export class TransactionArgumentU128 extends TransactionArgument { - public readonly value: bigint; - - constructor(value: bigint) { - super(); - this.value = value; - } - - serialize(serializer: Serializer): void { - serializer.serializeU32AsUleb128(RustEnumTransactionArgumentVariants.TransactionArgumentU128); - serializer.serializeU128(this.value); - } - - static load(deserializer: Deserializer): TransactionArgumentU128 { - const value = deserializer.deserializeU128(); - return new TransactionArgumentU128(value); - } -} - -export class TransactionArgumentU256 extends TransactionArgument { - public readonly value: bigint; - - constructor(value: bigint) { - super(); - this.value = value; - } - - serialize(serializer: Serializer): void { - serializer.serializeU32AsUleb128(RustEnumTransactionArgumentVariants.TransactionArgumentU256); - serializer.serializeU256(this.value); - } - - static load(deserializer: Deserializer): TransactionArgumentU256 { - const value = deserializer.deserializeU256(); - return new TransactionArgumentU256(value); - } -} - -export class TransactionArgumentAddress extends TransactionArgument { - public readonly value: AccountAddress; - - constructor(value: AccountAddress) { - super(); - this.value = value; - } - - serialize(serializer: Serializer): void { - serializer.serializeU32AsUleb128(RustEnumTransactionArgumentVariants.TransactionArgumentAddress); - this.value.serialize(serializer); - } - - static load(deserializer: Deserializer): TransactionArgumentAddress { - const value = AccountAddress.deserialize(deserializer); - return new TransactionArgumentAddress(value); - } -} - -export class TransactionArgumentU8Vector extends TransactionArgument { - public readonly value: Uint8Array; - - constructor(value: Uint8Array) { - super(); - this.value = value; - } - - serialize(serializer: Serializer): void { - serializer.serializeU32AsUleb128(RustEnumTransactionArgumentVariants.TransactionArgumentU8Vector); - serializer.serializeBytes(this.value); - } - - static load(deserializer: Deserializer): TransactionArgumentU8Vector { - const value = deserializer.deserializeBytes(); - return new TransactionArgumentU8Vector(value); - } -} - -export class TransactionArgumentBool extends TransactionArgument { - public readonly value: boolean; - - constructor(value: boolean) { - super(); - this.value = value; - } - - serialize(serializer: Serializer): void { - serializer.serializeU32AsUleb128(RustEnumTransactionArgumentVariants.TransactionArgumentBool); - serializer.serializeBool(this.value); - } - - static load(deserializer: Deserializer): TransactionArgumentBool { - const value = deserializer.deserializeBool(); - return new TransactionArgumentBool(value); - } -} diff --git a/ecosystem/typescript/sdk_v2/src/transactions/types/transactionPayload.ts b/ecosystem/typescript/sdk_v2/src/transactions/types/transactionPayload.ts index 2d3e0b7c35e9b..f029a525449a1 100644 --- a/ecosystem/typescript/sdk_v2/src/transactions/types/transactionPayload.ts +++ b/ecosystem/typescript/sdk_v2/src/transactions/types/transactionPayload.ts @@ -3,9 +3,9 @@ import { Serializer, Deserializer, Serializable } from "../../bcs"; import { AccountAddress } from "../../core"; import { Identifier } from "./identifier"; -import { TransactionArgument } from "./transactionArguments"; +import { ScriptTransactionArgument } from "./scriptTransactionArguments"; import { ModuleId } from "./moduleId"; -import { RustEnumTransactionPayloadVariants } from "../../types"; +import { TransactionPayloadVariants } from "../../types"; /** * Representation of the supported Transaction Payload @@ -24,11 +24,11 @@ export abstract class TransactionPayload extends Serializable { // index enum variant const index = deserializer.deserializeUleb128AsU32(); switch (index) { - case RustEnumTransactionPayloadVariants.TransactionPayloadScript: + case TransactionPayloadVariants.TransactionPayloadScript: return TransactionPayloadScript.load(deserializer); - case RustEnumTransactionPayloadVariants.TransactionPayloadEntryFunction: + case TransactionPayloadVariants.TransactionPayloadEntryFunction: return TransactionPayloadEntryFunction.load(deserializer); - case RustEnumTransactionPayloadVariants.TransactionPayloadMultisig: + case TransactionPayloadVariants.TransactionPayloadMultisig: return TransactionPayloadMultisig.load(deserializer); default: throw new Error(`Unknown variant index for TransactionPayload: ${index}`); @@ -48,7 +48,7 @@ export class TransactionPayloadScript extends TransactionPayload { } serialize(serializer: Serializer): void { - serializer.serializeU32AsUleb128(RustEnumTransactionPayloadVariants.TransactionPayloadScript); + serializer.serializeU32AsUleb128(TransactionPayloadVariants.TransactionPayloadScript); this.script.serialize(serializer); } @@ -70,7 +70,7 @@ export class TransactionPayloadEntryFunction extends TransactionPayload { } serialize(serializer: Serializer): void { - serializer.serializeU32AsUleb128(RustEnumTransactionPayloadVariants.TransactionPayloadEntryFunction); + serializer.serializeU32AsUleb128(TransactionPayloadVariants.TransactionPayloadEntryFunction); this.entryFunction.serialize(serializer); } @@ -92,7 +92,7 @@ export class TransactionPayloadMultisig extends TransactionPayload { } serialize(serializer: Serializer): void { - serializer.serializeU32AsUleb128(RustEnumTransactionPayloadVariants.TransactionPayloadMultisig); + serializer.serializeU32AsUleb128(TransactionPayloadVariants.TransactionPayloadMultisig); this.multiSig.serialize(serializer); } @@ -184,7 +184,7 @@ export class Script { /** * The arugments that the bytecode function requires. */ - public readonly args: Array; + public readonly args: Array; /** * Scripts contain the Move bytecodes payload that can be submitted to Aptos chain for execution. @@ -205,7 +205,7 @@ export class Script { * public(script) fun transfer(from: &signer, to: address, amount: u64,) * ``` */ - constructor(bytecode: Uint8Array, type_args: Array, args: Array) { + constructor(bytecode: Uint8Array, type_args: Array, args: Array) { this.bytecode = bytecode; this.type_args = type_args; this.args = args; @@ -214,13 +214,13 @@ export class Script { serialize(serializer: Serializer): void { serializer.serializeBytes(this.bytecode); serializer.serializeVector(this.type_args); - serializer.serializeVector(this.args); + serializer.serializeVector(this.args); } static deserialize(deserializer: Deserializer): Script { const bytecode = deserializer.deserializeBytes(); const type_args = deserializer.deserializeVector(TypeTag); - const args = deserializer.deserializeVector(TransactionArgument); + const args = deserializer.deserializeVector(ScriptTransactionArgument); return new Script(bytecode, type_args, args); } } diff --git a/ecosystem/typescript/sdk_v2/src/types/index.ts b/ecosystem/typescript/sdk_v2/src/types/index.ts index f5e71249724f3..b6faed1bbec99 100644 --- a/ecosystem/typescript/sdk_v2/src/types/index.ts +++ b/ecosystem/typescript/sdk_v2/src/types/index.ts @@ -8,26 +8,26 @@ export * from "./indexer"; export type HexInput = string | Uint8Array; /** - * Transaction argumtns enum as they are represented in Rust + * Script transaction arguments enum as they are represented in Rust * {@link https://github.com/aptos-labs/aptos-core/blob/main/third_party/move/move-core/types/src/transaction_argument.rs#L11} */ -export enum RustEnumTransactionArgumentVariants { - TransactionArgumentU8 = 0, - TransactionArgumentU64 = 1, - TransactionArgumentU128 = 2, - TransactionArgumentAddress = 3, - TransactionArgumentU8Vector = 4, - TransactionArgumentBool = 5, - TransactionArgumentU16 = 6, - TransactionArgumentU32 = 7, - TransactionArgumentU256 = 8, +export enum ScriptTransactionArgumentVariants { + ScriptTransactionArgumentU8 = 0, + ScriptTransactionArgumentU64 = 1, + ScriptTransactionArgumentU128 = 2, + ScriptTransactionArgumentAddress = 3, + ScriptTransactionArgumentU8Vector = 4, + ScriptTransactionArgumentBool = 5, + ScriptTransactionArgumentU16 = 6, + ScriptTransactionArgumentU32 = 7, + ScriptTransactionArgumentU256 = 8, } /** * Transaction payload enum as they are represented in Rust * {@link https://github.com/aptos-labs/aptos-core/blob/main/types/src/transaction/mod.rs#L478} */ -export enum RustEnumTransactionPayloadVariants { +export enum TransactionPayloadVariants { TransactionPayloadScript = 0, TransactionPayloadEntryFunction = 2, TransactionPayloadMultisig = 3, @@ -37,7 +37,7 @@ export enum RustEnumTransactionPayloadVariants { * Transaction variants enum as they are represented in Rust * {@link https://github.com/aptos-labs/aptos-core/blob/main/types/src/transaction/mod.rs#L440} */ -export enum RustEnumTransactionVariants { +export enum TransactionVariants { MultiAgentTransaction = 0, FeePayerTransaction = 1, } @@ -46,7 +46,7 @@ export enum RustEnumTransactionVariants { * Transaction Authenticator enum as they are represented in Rust * {@link https://github.com/aptos-labs/aptos-core/blob/main/types/src/transaction/authenticator.rs#L44} */ -export enum RustEnumTransactionAuthenticatorVariant { +export enum TransactionAuthenticatorVariant { TransactionAuthenticatorEd25519 = 0, TransactionAuthenticatorMultiEd25519 = 1, TransactionAuthenticatorMultiAgent = 2, @@ -57,7 +57,7 @@ export enum RustEnumTransactionAuthenticatorVariant { * Transaction Authenticator enum as they are represented in Rust * {@link https://github.com/aptos-labs/aptos-core/blob/main/types/src/transaction/authenticator.rs#L414} */ -export enum RustEnumAccountAuthenticatorVariant { +export enum AccountAuthenticatorVariant { AccountAuthenticatorEd25519 = 0, AccountAuthenticatorMultiEd25519 = 1, }