@aeternity/aepp-sdk 13.2.1 → 13.3.0

package/types-legacy/ts4.5/deprecated.d.ts

@@ -1,4 +1,7 @@
+import { AciValue } from './utils/typed-data';
+import { Encoded } from './utils/encoder';
 import { RpcError } from './aepp-wallet-communication/schema';
+import { ORACLE_TTL_TYPES } from './tx/builder/schema';
 /**
  * @category exception
  * @deprecated this exception is not thrown anymore
@@ -12,3 +15,48 @@ export declare class RpcBroadcastError extends RpcError {
  * @deprecated use isAuctionName instead
  */
 export declare const NAME_BID_MAX_LENGTH = 12;
+/**
+ * @deprecated use ContractByteArrayEncoder:encodeWithType from \@aeternity/aepp-calldata
+ */
+export declare function encodeFateValue(value: unknown, aci: AciValue): Encoded.ContractBytearray;
+/**
+ * @deprecated use ContractByteArrayEncoder:decodeWithType from \@aeternity/aepp-calldata
+ */
+export declare function decodeFateValue(value: Encoded.ContractBytearray, aci: AciValue): any;
+/**
+ * @deprecated inlined in buildTx or use `180000`
+ */
+export declare const NAME_TTL = 180000;
+/**
+ * @deprecated inlined in buildTx or use `36000`
+ */
+export declare const NAME_MAX_TTL = 36000;
+/**
+ * @deprecated inlined in buildTx or use `60 * 60`
+ */
+export declare const NAME_MAX_CLIENT_TTL: number;
+/**
+ * @deprecated inlined in buildTx or use `60 * 60`
+ */
+export declare const CLIENT_TTL: number;
+/**
+ * @deprecated inlined in buildTx or use `{ type: ORACLE_TTL_TYPES.delta, value: 500 }`
+ */
+export declare const ORACLE_TTL: {
+    type: ORACLE_TTL_TYPES;
+    value: number;
+};
+/**
+ * @deprecated inlined in buildTx or use `{ type: ORACLE_TTL_TYPES.delta, value: 10 }`
+ */
+export declare const QUERY_TTL: {
+    type: ORACLE_TTL_TYPES;
+    value: number;
+};
+/**
+ * @deprecated inlined in buildTx or use `{ type: ORACLE_TTL_TYPES.delta, value: 10 }`
+ */
+export declare const RESPONSE_TTL: {
+    type: ORACLE_TTL_TYPES;
+    value: number;
+};

package/types-legacy/ts4.5/index-browser.d.ts

@@ -1,19 +1,24 @@
-export { _getPollInterval, InvalidTxError, getHeight, poll, awaitHeight, waitForTxConfirm, sendTransaction, getAccount, getBalance, getCurrentGeneration, getGeneration, getMicroBlockTransactions, getKeyBlock, getMicroBlockHeader, txDryRun, getContractByteCode, getContract, getName, resolveName, } from './chain';
+export { _getPollInterval, getHeight, poll, awaitHeight, waitForTxConfirm, getAccount, getBalance, getCurrentGeneration, getGeneration, getMicroBlockTransactions, getKeyBlock, getMicroBlockHeader, txDryRun, getContractByteCode, getContract, getName, resolveName, } from './chain';
+export { InvalidTxError, sendTransaction } from './send-transaction';
 export { getAddressFromPriv, isAddressValid, genSalt, encodeUnsigned, hash, encodeContractAddress, generateKeyPairFromSecret, generateKeyPair, sign, verify, messageToHash, signMessage, verifyMessage, isValidKeypair, } from './utils/crypto';
+export { signJwt, unpackJwt, verifyJwt, isJwt, ensureJwt, } from './utils/jwt';
+export type { Jwt } from './utils/jwt';
 export { recover, dump } from './utils/keystore';
 export type { Keystore } from './utils/keystore';
 export { toBytes } from './utils/bytes';
 export { buildTx, buildTxAsync, buildTxHash, unpackTx, buildContractIdByContractTx, } from './tx/builder';
 export { buildContractId, oracleQueryId, produceNameId, commitmentHash, readInt, isNameValid, ensureName, getDefaultPointerKey, getMinimumNameFee, computeBidFee, computeAuctionEndBlock, isAuctionName, } from './tx/builder/helpers';
-export { MAX_AUTH_FUN_GAS, NAME_TTL, NAME_MAX_TTL, NAME_MAX_CLIENT_TTL, CLIENT_TTL, MIN_GAS_PRICE, NAME_FEE_MULTIPLIER, NAME_FEE_BID_INCREMENT, NAME_BID_TIMEOUT_BLOCKS, NAME_MAX_LENGTH_FEE, NAME_BID_RANGES, ConsensusProtocolVersion, VmVersion, AbiVersion, Tag, } from './tx/builder/constants';
+export { MAX_AUTH_FUN_GAS, MIN_GAS_PRICE, NAME_FEE_MULTIPLIER, NAME_FEE_BID_INCREMENT, NAME_BID_TIMEOUT_BLOCKS, NAME_MAX_LENGTH_FEE, NAME_BID_RANGES, ConsensusProtocolVersion, VmVersion, AbiVersion, Tag, DRY_RUN_ACCOUNT, } from './tx/builder/constants';
 export type { Int, AensName } from './tx/builder/constants';
-export { ORACLE_TTL_TYPES, ORACLE_TTL, QUERY_TTL, RESPONSE_TTL, DRY_RUN_ACCOUNT, CallReturnType, } from './tx/builder/schema';
+export { ORACLE_TTL_TYPES, CallReturnType } from './tx/builder/schema';
+export { DelegationTag } from './tx/builder/delegation/schema';
+export { packDelegation, unpackDelegation } from './tx/builder/delegation';
 export { getExecutionCost, getExecutionCostBySignedTx, getExecutionCostUsingNode, } from './tx/execution-cost';
 export { default as getTransactionSignerAddress } from './tx/transaction-signer';
 export { AE_AMOUNT_FORMATS, formatAmount, toAe, toAettos, prefixedAmount, } from './utils/amount-formatter';
 export { DerivationError, deriveChild, derivePathFromKey, getMasterKeyFromSeed, derivePathFromSeed, getKeyPair, generateSaveHDWalletFromSeed, getSaveHDWalletAccounts, getHdWalletAccountFromSeed, } from './utils/hd-wallet';
 export { encode, decode, Encoding, Encoded, } from './utils/encoder';
-export { encodeFateValue, decodeFateValue, hashTypedData, hashDomain, hashJson, } from './utils/typed-data';
+export { hashTypedData, hashDomain, hashJson } from './utils/typed-data';
 export { aensRevoke, aensUpdate, aensTransfer, aensQuery, aensClaim, aensPreclaim, aensBid, } from './aens';
 export { default as Contract } from './contract/Contract';
 export type { ContractMethodsBase } from './contract/Contract';
@@ -42,5 +47,5 @@ export { MESSAGE_DIRECTION, WALLET_TYPE, SUBSCRIPTION_TYPES, METHODS, RPC_STATUS
 export { default as walletDetector } from './aepp-wallet-communication/wallet-detector';
 export { default as BrowserRuntimeConnection } from './aepp-wallet-communication/connection/BrowserRuntime';
 export { default as BrowserWindowMessageConnection } from './aepp-wallet-communication/connection/BrowserWindowMessage';
-export { BaseError, AccountError, AensError, AeppError, ChannelError, CompilerError, ContractError, CryptographyError, NodeError, TransactionError, WalletError, ArgumentError, IllegalArgumentError, ArgumentCountMismatchError, InsufficientBalanceError, MissingParamError, NoSerializerFoundError, RequestTimedOutError, TxTimedOutError, TypeError, UnsupportedPlatformError, UnsupportedProtocolError, NotImplementedError, UnsupportedVersionError, InternalError, UnexpectedTsError, UnavailableAccountError, AensPointerContextError, InsufficientNameFeeError, InvalidAensNameError, InvalidRpcMessageError, MissingCallbackError, UnAuthorizedAccountError, UnknownRpcClientError, UnsubscribedAccountError, ChannelCallError, ChannelConnectionError, ChannelPingTimedOutError, UnexpectedChannelMessageError, ChannelIncomingMessageError, UnknownChannelStateError, InvalidAuthDataError, BytecodeMismatchError, DuplicateContractError, InactiveContractError, InvalidMethodInvocationError, MissingContractAddressError, MissingContractDefError, MissingFunctionNameError, NodeInvocationError, NoSuchContractFunctionError, NotPayableFunctionError, MissingEventDefinitionError, AmbiguousEventDefinitionError, InvalidChecksumError, InvalidPasswordError, MerkleTreeHashMismatchError, MissingNodeInTreeError, UnknownNodeLengthError, UnknownPathNibbleError, DuplicateNodeError, NodeNotFoundError, DecodeError, PayloadLengthError, DryRunError, IllegalBidFeeError, InvalidSignatureError, PrefixNotFoundError, SchemaNotFoundError, TagNotFoundError, TxNotInChainError, AlreadyConnectedError, NoWalletConnectedError, RpcConnectionError, } from './utils/errors';
-export { RpcBroadcastError, NAME_BID_MAX_LENGTH } from './deprecated';
+export { BaseError, AccountError, AensError, AeppError, ChannelError, CompilerError, ContractError, CryptographyError, NodeError, TransactionError, WalletError, ArgumentError, IllegalArgumentError, ArgumentCountMismatchError, InsufficientBalanceError, MissingParamError, NoSerializerFoundError, RequestTimedOutError, TxTimedOutError, TypeError, UnsupportedPlatformError, UnsupportedProtocolError, NotImplementedError, UnsupportedVersionError, LogicError, InternalError, UnexpectedTsError, UnavailableAccountError, AensPointerContextError, InsufficientNameFeeError, InvalidAensNameError, InvalidRpcMessageError, MissingCallbackError, UnAuthorizedAccountError, UnknownRpcClientError, UnsubscribedAccountError, ChannelCallError, ChannelConnectionError, ChannelPingTimedOutError, UnexpectedChannelMessageError, ChannelIncomingMessageError, UnknownChannelStateError, InvalidAuthDataError, BytecodeMismatchError, DuplicateContractError, InactiveContractError, InvalidMethodInvocationError, MissingContractAddressError, MissingContractDefError, MissingFunctionNameError, NodeInvocationError, NoSuchContractFunctionError, NotPayableFunctionError, MissingEventDefinitionError, AmbiguousEventDefinitionError, InvalidChecksumError, InvalidPasswordError, MerkleTreeHashMismatchError, MissingNodeInTreeError, UnknownNodeLengthError, UnknownPathNibbleError, DuplicateNodeError, NodeNotFoundError, DecodeError, PayloadLengthError, DryRunError, IllegalBidFeeError, InvalidSignatureError, PrefixNotFoundError, SchemaNotFoundError, TagNotFoundError, TxNotInChainError, AlreadyConnectedError, NoWalletConnectedError, RpcConnectionError, } from './utils/errors';
+export { RpcBroadcastError, NAME_BID_MAX_LENGTH, encodeFateValue, decodeFateValue, NAME_TTL, NAME_MAX_TTL, NAME_MAX_CLIENT_TTL, CLIENT_TTL, ORACLE_TTL, QUERY_TTL, RESPONSE_TTL, } from './deprecated';

package/types-legacy/ts4.5/index.d.ts

@@ -1,4 +1,5 @@
 export * from './index-browser';
 export { default as CompilerCli } from './contract/compiler/Cli';
+export { default as CompilerCli8 } from './contract/compiler/Cli8';
 export { default as getFileSystem } from './contract/compiler/getFileSystem';
 export { default as CompilerHttpNode } from './contract/compiler/HttpNode';

package/types-legacy/ts4.5/oracle.d.ts

@@ -6,10 +6,10 @@
  * repository.
  */
 import { BuildTxOptions } from './tx/builder';
-import { ORACLE_TTL_TYPES } from './tx/builder/schema';
 import { Tag } from './tx/builder/constants';
 import { Encoded } from './utils/encoder';
-import { _getPollInterval, sendTransaction, SendTransactionOptions } from './chain';
+import { _getPollInterval } from './chain';
+import { sendTransaction, SendTransactionOptions } from './send-transaction';
 import Node from './Node';
 import AccountBase from './account/Base';
 type OracleQueries = Awaited<ReturnType<Node['getOracleQueriesByPubkey']>>['oracleQueries'];
@@ -62,37 +62,20 @@ interface GetQueryObjectReturnType extends Awaited<ReturnType<Node['getOracleQue
  * @param oracleId - Oracle public key
  * @param query - Oracle query object
  * @param options - Options object
- * @param options.queryTtl - queryTtl Oracle query time to leave
- * @param options.responseTtl - queryFee Oracle query response time to leave
- * @param options.queryFee - queryFee Oracle query fee
- * @param options.fee - fee Transaction fee
- * @param options.ttl - Transaction time to leave
  * @returns Query object
  */
 export declare function postQueryToOracle(oracleId: Encoded.OracleAddress, query: string, options: PostQueryToOracleOptions): Promise<Awaited<ReturnType<typeof sendTransaction>> & Awaited<ReturnType<typeof getQueryObject>>>;
-type PostQueryToOracleOptionsType = Parameters<typeof sendTransaction>[1] & Parameters<typeof getQueryObject>[2] & BuildTxOptions<Tag.OracleQueryTx, 'oracleId' | 'senderId' | 'query' | 'queryTtlType' | 'queryTtlValue' | 'responseTtlType' | 'responseTtlValue'> & {
-    queryTtlType?: ORACLE_TTL_TYPES;
-    queryTtlValue?: number;
-    responseTtlType?: ORACLE_TTL_TYPES;
-    responseTtlValue?: number;
-};
+type PostQueryToOracleOptionsType = Parameters<typeof sendTransaction>[1] & Parameters<typeof getQueryObject>[2] & BuildTxOptions<Tag.OracleQueryTx, 'oracleId' | 'senderId' | 'query'>;
 interface PostQueryToOracleOptions extends PostQueryToOracleOptionsType {
 }
 /**
  * Extend oracle ttl
  * @category oracle
  * @param options - Options object
- * @param options.fee - fee Transaction fee
- * @param options.ttl - Transaction time to leave
- * @param options.oracleTtlType - Oracle time to leave for extend
- * @param options.oracleTtlValue - Oracle time to leave for extend
  * @returns Oracle object
  */
 export declare function extendOracleTtl(options: ExtendOracleTtlOptions): Promise<Awaited<ReturnType<typeof sendTransaction>> & Awaited<ReturnType<typeof getOracleObject>>>;
-type ExtendOracleTtlOptionsType = SendTransactionOptions & Parameters<typeof getOracleObject>[1] & BuildTxOptions<Tag.OracleExtendTx, 'oracleTtlType' | 'oracleTtlValue' | 'callerId' | 'oracleId'> & {
-    oracleTtlType?: ORACLE_TTL_TYPES;
-    oracleTtlValue?: number;
-};
+type ExtendOracleTtlOptionsType = SendTransactionOptions & Parameters<typeof getOracleObject>[1] & BuildTxOptions<Tag.OracleExtendTx, 'callerId' | 'oracleId'>;
 interface ExtendOracleTtlOptions extends ExtendOracleTtlOptionsType {
 }
 /**
@@ -101,16 +84,10 @@ interface ExtendOracleTtlOptions extends ExtendOracleTtlOptionsType {
  * @param queryId - Oracle query id
  * @param response - Oracle query response
  * @param options - Options object
- * @param options.responseTtl - responseTtl Query response time to leave
- * @param options.fee - Transaction fee
- * @param options.ttl - Transaction time to leave
  * @returns Oracle object
  */
 export declare function respondToQuery(queryId: Encoded.OracleQueryId, response: string, options: RespondToQueryOptions): Promise<Awaited<ReturnType<typeof sendTransaction>> & Awaited<ReturnType<typeof getOracleObject>>>;
-type RespondToQueryOptionsType = SendTransactionOptions & Parameters<typeof getOracleObject>[1] & BuildTxOptions<Tag.OracleResponseTx, 'callerId' | 'oracleId' | 'queryId' | 'response' | 'responseTtlType' | 'responseTtlValue'> & {
-    responseTtlType?: ORACLE_TTL_TYPES;
-    responseTtlValue?: number;
-};
+type RespondToQueryOptionsType = SendTransactionOptions & Parameters<typeof getOracleObject>[1] & BuildTxOptions<Tag.OracleResponseTx, 'callerId' | 'oracleId' | 'queryId' | 'response'>;
 interface RespondToQueryOptions extends RespondToQueryOptionsType {
 }
 /**
@@ -139,18 +116,10 @@ interface GetOracleObjectReturnType extends Awaited<ReturnType<Node['getOracleBy
  * @param queryFormat - Format of query
  * @param responseFormat - Format of query response
  * @param options - Options
- * @param options.queryFee - Oracle query Fee
- * @param options - Options object
- * @param options.abiVersion - Always 0 (do not use virtual machine)
- * @param options.fee - Transaction fee
- * @param options.ttl - Transaction time to leave
  * @returns Oracle object
  */
 export declare function registerOracle(queryFormat: string, responseFormat: string, options: RegisterOracleOptions): Promise<Awaited<ReturnType<typeof sendTransaction>> & Awaited<ReturnType<typeof getOracleObject>>>;
-type RegisterOracleOptionsType = SendTransactionOptions & Parameters<typeof getOracleObject>[1] & BuildTxOptions<Tag.OracleRegisterTx, 'accountId' | 'queryFormat' | 'responseFormat' | 'oracleTtlType' | 'oracleTtlValue'> & {
-    oracleTtlType?: ORACLE_TTL_TYPES;
-    oracleTtlValue?: number;
-};
+type RegisterOracleOptionsType = SendTransactionOptions & Parameters<typeof getOracleObject>[1] & BuildTxOptions<Tag.OracleRegisterTx, 'accountId' | 'queryFormat' | 'responseFormat'>;
 interface RegisterOracleOptions extends RegisterOracleOptionsType {
 }
 export {};

package/types-legacy/ts4.5/send-transaction.d.ts

@@ -0,0 +1,53 @@
+import { ValidatorResult } from './tx/validator';
+import { TransactionError } from './utils/errors';
+import Node, { TransformNodeType } from './Node';
+import { SignedTx } from './apis/node';
+import { Encoded } from './utils/encoder';
+import AccountBase from './account/Base';
+import { poll, waitForTxConfirm } from './chain';
+/**
+ * @category exception
+ */
+export declare class InvalidTxError extends TransactionError {
+    validation: ValidatorResult[];
+    transaction: Encoded.Transaction;
+    constructor(message: string, validation: ValidatorResult[], transaction: Encoded.Transaction);
+}
+/**
+ * Signs and submits transaction for mining
+ * @category chain
+ * @param txUnsigned - Transaction to sign and submit
+ * @param options - Options
+ * @returns Transaction details
+ */
+export declare function sendTransaction(txUnsigned: Encoded.Transaction, { onNode, onAccount, verify, waitMined, confirm, innerTx, ...options }: SendTransactionOptions): Promise<SendTransactionReturnType>;
+type SendTransactionOptionsType = {
+    /**
+     * Node to use
+     */
+    onNode: Node;
+    /**
+     * Account to use
+     */
+    onAccount: AccountBase;
+    /**
+     * Verify transaction before broadcast, throw error if not
+     */
+    verify?: boolean;
+    /**
+     * Ensure that transaction get into block
+     */
+    waitMined?: boolean;
+    /**
+     * Number of micro blocks that should be mined after tx get included
+     */
+    confirm?: boolean | number;
+} & Parameters<typeof poll>[1] & Omit<Parameters<typeof waitForTxConfirm>[1], 'confirm'> & Parameters<AccountBase['signTransaction']>[1];
+export interface SendTransactionOptions extends SendTransactionOptionsType {
+}
+interface SendTransactionReturnType extends Partial<TransformNodeType<SignedTx>> {
+    hash: Encoded.TxHash;
+    rawTx: Encoded.Transaction;
+    confirmationHeight?: number;
+}
+export {};

package/types-legacy/ts4.5/spend.d.ts

@@ -1,4 +1,5 @@
-import { sendTransaction, resolveName, SendTransactionOptions } from './chain';
+import { resolveName } from './chain';
+import { sendTransaction, SendTransactionOptions } from './send-transaction';
 import { BuildTxOptions } from './tx/builder';
 import { Encoded } from './utils/encoder';
 import { Tag, AensName } from './tx/builder/constants';
@@ -11,7 +12,7 @@ import AccountBase from './account/Base';
  * @param options - Options
  * @returns Transaction
  */
-export declare function spend(amount: number | string, recipientIdOrName: Encoded.AccountAddress | AensName, options: SpendOptions): ReturnType<typeof sendTransaction>;
+export declare function spend(amount: number | string, recipientIdOrName: Encoded.AccountAddress | Encoded.ContractAddress | AensName, options: SpendOptions): ReturnType<typeof sendTransaction>;
 type SpendOptionsType = BuildTxOptions<Tag.SpendTx, 'senderId' | 'recipientId' | 'amount'> & Parameters<typeof resolveName>[2] & {
     onAccount: AccountBase;
 } & SendTransactionOptions;
@@ -35,7 +36,7 @@ interface SpendOptions extends SpendOptionsType {
  * ```
  */
 export declare function transferFunds(fraction: number | string, // TODO: accept only number
-recipientIdOrName: AensName | Encoded.AccountAddress, options: TransferFundsOptions): ReturnType<typeof sendTransaction>;
+recipientIdOrName: AensName | Encoded.AccountAddress | Encoded.ContractAddress, options: TransferFundsOptions): ReturnType<typeof sendTransaction>;
 type TransferFundsOptionsType = BuildTxOptions<Tag.SpendTx, 'senderId' | 'recipientId' | 'amount'> & Parameters<typeof resolveName>[2] & {
     onAccount: AccountBase;
 } & SendTransactionOptions;

package/types-legacy/ts4.5/tx/builder/common.d.ts

@@ -0,0 +1,32 @@
+import { Field } from './field-types';
+import { Encoding, Encoded } from '../../utils/encoder';
+type Schemas = ReadonlyArray<{
+    tag: {
+        constValue: number;
+    } & Field;
+    version: {
+        constValue: number;
+        constValueOptional: boolean;
+    } & Field;
+}>;
+export declare function getSchema(schemas: Schemas, Tag: {
+    [key: number]: string;
+}, tag: number, version: number | undefined): Array<[
+    string,
+    Field
+]>;
+export declare function packRecord<E extends Encoding>(schemas: Schemas, Tag: {
+    [key: number]: string;
+}, params: {
+    tag: number;
+    version?: number;
+    [k: string]: unknown;
+}, extraParams: {
+    [k: string]: unknown;
+}, encoding: E): Encoded.Generic<E>;
+export declare function unpackRecord(schemas: Schemas, Tag: {
+    [key: number]: string;
+}, encodedRecord: Encoded.Any, expectedTag: number | undefined, extraParams: {
+    [k: string]: unknown;
+}): unknown;
+export {};

package/types-legacy/ts4.5/tx/builder/constants.d.ts

@@ -1,11 +1,11 @@
 import BigNumber from 'bignumber.js';
+export declare const DRY_RUN_ACCOUNT: {
+    readonly pub: "ak_11111111111111111111111111111111273Yts";
+    readonly amount: 100000000000000000000000000000000000n;
+};
 export declare const MAX_AUTH_FUN_GAS = 50000;
 export type Int = number | string | BigNumber;
 export type AensName = `${string}.chain`;
-export declare const NAME_TTL = 180000;
-export declare const NAME_MAX_TTL = 36000;
-export declare const NAME_MAX_CLIENT_TTL = 84600;
-export declare const CLIENT_TTL = 84600;
 export declare const MIN_GAS_PRICE = 1000000000;
 export declare const NAME_FEE_MULTIPLIER = 100000000000000;
 export declare const NAME_FEE_BID_INCREMENT = 0.05;
@@ -29,7 +29,8 @@ export declare enum VmVersion {
     SophiaImprovementsFortuna = 4,
     Fate = 5,
     SophiaImprovementsLima = 6,
-    Fate2 = 7
+    Fate2 = 7,
+    Fate3 = 8
 }
 /**
  * @category transaction builder

package/types-legacy/ts4.5/tx/builder/delegation/index.d.ts

@@ -0,0 +1,20 @@
+import { Encoded } from '../../../utils/encoder';
+import { DelegationTag } from './schema';
+import { DlgParams, DlgUnpacked } from './schema.generated';
+/**
+ * Pack delegation
+ * @category delegation signature
+ * @param params - Params of delegation
+ * @returns Encoded delegation
+ */
+export declare function packDelegation(params: DlgParams): Encoded.Bytearray;
+/**
+ * Unpack delegation
+ * @category delegation signature
+ * @param encoded - Encoded delegation
+ * @param expectedTag - Expected delegation signature type
+ * @returns Params of delegation
+ */
+export declare function unpackDelegation<T extends DelegationTag>(encoded: Encoded.Bytearray, expectedTag?: T): DlgUnpacked & {
+    tag: T;
+};

package/types-legacy/ts4.5/tx/builder/delegation/schema.d.ts

@@ -0,0 +1,136 @@
+/// <reference types="node" />
+import SchemaTypes from '../SchemaTypes';
+import { Encoded } from '../../../utils/encoder';
+/**
+ * @category delegation signature
+ */
+export declare enum DelegationTag {
+    AensWildcard = 1,
+    AensName = 2,
+    AensPreclaim = 3,
+    Oracle = 4,
+    OracleResponse = 5
+}
+/**
+ * @see {@link https://github.com/aeternity/protocol/blob/8a9d1d1206174627f6aaef86159dc9c643080653/contracts/fate.md#from-ceres-serialized-signature-data}
+ */
+export declare const schemas: readonly [
+    {
+        readonly tag: {
+            serialize: (value: DelegationTag.AensWildcard) => Buffer;
+            deserialize: (value: Buffer) => DelegationTag.AensWildcard;
+            constValue: DelegationTag.AensWildcard;
+            constValueOptional: boolean;
+        };
+        readonly version: {
+            serialize: (value?: 1 | undefined) => Buffer;
+            deserialize: (value: Buffer) => 1;
+            constValue: 1;
+            constValueOptional: boolean;
+        };
+        readonly accountAddress: {
+            serialize: (value: `ak_${string}`) => Buffer;
+            deserialize: (value: Buffer) => `ak_${string}`;
+        };
+        readonly contractAddress: {
+            serialize: (value: `ct_${string}`) => Buffer;
+            deserialize: (value: Buffer) => `ct_${string}`;
+        };
+    },
+    {
+        readonly tag: {
+            serialize: (value: DelegationTag.AensName) => Buffer;
+            deserialize: (value: Buffer) => DelegationTag.AensName;
+            constValue: DelegationTag.AensName;
+            constValueOptional: boolean;
+        };
+        readonly version: {
+            serialize: (value?: 1 | undefined) => Buffer;
+            deserialize: (value: Buffer) => 1;
+            constValue: 1;
+            constValueOptional: boolean;
+        };
+        readonly accountAddress: {
+            serialize: (value: `ak_${string}`) => Buffer;
+            deserialize: (value: Buffer) => `ak_${string}`;
+        };
+        readonly nameId: {
+            serialize(value: `${string}.chain` | `nm_${string}`): Buffer;
+            deserialize: (value: Buffer) => `nm_${string}`;
+        };
+        readonly contractAddress: {
+            serialize: (value: `ct_${string}`) => Buffer;
+            deserialize: (value: Buffer) => `ct_${string}`;
+        };
+    },
+    {
+        readonly tag: {
+            serialize: (value: DelegationTag.AensPreclaim) => Buffer;
+            deserialize: (value: Buffer) => DelegationTag.AensPreclaim;
+            constValue: DelegationTag.AensPreclaim;
+            constValueOptional: boolean;
+        };
+        readonly version: {
+            serialize: (value?: 1 | undefined) => Buffer;
+            deserialize: (value: Buffer) => 1;
+            constValue: 1;
+            constValueOptional: boolean;
+        };
+        readonly accountAddress: {
+            serialize: (value: `ak_${string}`) => Buffer;
+            deserialize: (value: Buffer) => `ak_${string}`;
+        };
+        readonly contractAddress: {
+            serialize: (value: `ct_${string}`) => Buffer;
+            deserialize: (value: Buffer) => `ct_${string}`;
+        };
+    },
+    {
+        readonly tag: {
+            serialize: (value: DelegationTag.Oracle) => Buffer;
+            deserialize: (value: Buffer) => DelegationTag.Oracle;
+            constValue: DelegationTag.Oracle;
+            constValueOptional: boolean;
+        };
+        readonly version: {
+            serialize: (value?: 1 | undefined) => Buffer;
+            deserialize: (value: Buffer) => 1;
+            constValue: 1;
+            constValueOptional: boolean;
+        };
+        readonly accountAddress: {
+            serialize: (value: `ak_${string}`) => Buffer;
+            deserialize: (value: Buffer) => `ak_${string}`;
+        };
+        readonly contractAddress: {
+            serialize: (value: `ct_${string}`) => Buffer;
+            deserialize: (value: Buffer) => `ct_${string}`;
+        };
+    },
+    {
+        readonly tag: {
+            serialize: (value: DelegationTag.OracleResponse) => Buffer;
+            deserialize: (value: Buffer) => DelegationTag.OracleResponse;
+            constValue: DelegationTag.OracleResponse;
+            constValueOptional: boolean;
+        };
+        readonly version: {
+            serialize: (value?: 1 | undefined) => Buffer;
+            deserialize: (value: Buffer) => 1;
+            constValue: 1;
+            constValueOptional: boolean;
+        };
+        readonly queryId: {
+            readonly serialize: (value: Encoded.OracleQueryId) => Buffer;
+            readonly deserialize: (value: Buffer) => Encoded.OracleQueryId;
+        };
+        readonly contractAddress: {
+            serialize: (value: `ct_${string}`) => Buffer;
+            deserialize: (value: Buffer) => `ct_${string}`;
+        };
+    }
+];
+type Schemas = SchemaTypes<typeof schemas>;
+export type DlgParams = Schemas['TxParams'];
+export type DlgUnpacked = Schemas['TxUnpacked'];
+export {};

package/types-legacy/ts4.5/tx/builder/delegation/schema.generated.d.ts

@@ -0,0 +1,141 @@
+import { DlgParams as DlgParamsComplex, DlgUnpacked as DlgUnpackedComplex } from "./schema";
+import { DelegationTag as Tag } from "./schema";
+/**
+ * @category delegation signature
+ */
+type DlgParamsAensWildcard1Type = Omit<DlgParamsComplex & {
+    tag: Tag.AensWildcard;
+    version: 1;
+}, "version"> & {
+    version?: 1;
+};
+/**
+ * @category delegation signature
+ */
+export interface DlgParamsAensWildcard1 extends DlgParamsAensWildcard1Type {
+}
+/**
+ * @category delegation signature
+ */
+type DlgUnpackedAensWildcard1Type = DlgUnpackedComplex & {
+    tag: Tag.AensWildcard;
+    version: 1;
+};
+/**
+ * @category delegation signature
+ */
+export interface DlgUnpackedAensWildcard1 extends DlgUnpackedAensWildcard1Type {
+}
+/**
+ * @category delegation signature
+ */
+type DlgParamsAensName1Type = Omit<DlgParamsComplex & {
+    tag: Tag.AensName;
+    version: 1;
+}, "version"> & {
+    version?: 1;
+};
+/**
+ * @category delegation signature
+ */
+export interface DlgParamsAensName1 extends DlgParamsAensName1Type {
+}
+/**
+ * @category delegation signature
+ */
+type DlgUnpackedAensName1Type = DlgUnpackedComplex & {
+    tag: Tag.AensName;
+    version: 1;
+};
+/**
+ * @category delegation signature
+ */
+export interface DlgUnpackedAensName1 extends DlgUnpackedAensName1Type {
+}
+/**
+ * @category delegation signature
+ */
+type DlgParamsAensPreclaim1Type = Omit<DlgParamsComplex & {
+    tag: Tag.AensPreclaim;
+    version: 1;
+}, "version"> & {
+    version?: 1;
+};
+/**
+ * @category delegation signature
+ */
+export interface DlgParamsAensPreclaim1 extends DlgParamsAensPreclaim1Type {
+}
+/**
+ * @category delegation signature
+ */
+type DlgUnpackedAensPreclaim1Type = DlgUnpackedComplex & {
+    tag: Tag.AensPreclaim;
+    version: 1;
+};
+/**
+ * @category delegation signature
+ */
+export interface DlgUnpackedAensPreclaim1 extends DlgUnpackedAensPreclaim1Type {
+}
+/**
+ * @category delegation signature
+ */
+type DlgParamsOracle1Type = Omit<DlgParamsComplex & {
+    tag: Tag.Oracle;
+    version: 1;
+}, "version"> & {
+    version?: 1;
+};
+/**
+ * @category delegation signature
+ */
+export interface DlgParamsOracle1 extends DlgParamsOracle1Type {
+}
+/**
+ * @category delegation signature
+ */
+type DlgUnpackedOracle1Type = DlgUnpackedComplex & {
+    tag: Tag.Oracle;
+    version: 1;
+};
+/**
+ * @category delegation signature
+ */
+export interface DlgUnpackedOracle1 extends DlgUnpackedOracle1Type {
+}
+/**
+ * @category delegation signature
+ */
+type DlgParamsOracleResponse1Type = Omit<DlgParamsComplex & {
+    tag: Tag.OracleResponse;
+    version: 1;
+}, "version"> & {
+    version?: 1;
+};
+/**
+ * @category delegation signature
+ */
+export interface DlgParamsOracleResponse1 extends DlgParamsOracleResponse1Type {
+}
+/**
+ * @category delegation signature
+ */
+type DlgUnpackedOracleResponse1Type = DlgUnpackedComplex & {
+    tag: Tag.OracleResponse;
+    version: 1;
+};
+/**
+ * @category delegation signature
+ */
+export interface DlgUnpackedOracleResponse1 extends DlgUnpackedOracleResponse1Type {
+}
+/**
+ * @category delegation signature
+ */
+export type DlgParams = DlgParamsAensWildcard1 | DlgParamsAensName1 | DlgParamsAensPreclaim1 | DlgParamsOracle1 | DlgParamsOracleResponse1;
+/**
+ * @category delegation signature
+ */
+export type DlgUnpacked = DlgUnpackedAensWildcard1 | DlgUnpackedAensName1 | DlgUnpackedAensPreclaim1 | DlgUnpackedOracle1 | DlgUnpackedOracleResponse1;
+export {};

package/types-legacy/ts4.5/tx/builder/field-types/coin-amount.d.ts

@@ -2,8 +2,8 @@
 import { Int } from '../constants';
 import { AE_AMOUNT_FORMATS } from '../../../utils/amount-formatter';
 declare const _default: {
-    serializeAettos(value: string | undefined, params: {}): string;
-    serialize(value: Int | undefined, params: {}, { denomination }: {
+    serializeAettos(value: string | undefined, params: {}, options: {}): string;
+    serialize(value: Int | undefined, params: {}, { denomination, ...options }: {
         denomination?: AE_AMOUNT_FORMATS | undefined;
     }): Buffer;
     deserialize(value: Buffer): string;

package/types-legacy/ts4.5/tx/builder/field-types/ct-version.d.ts

@@ -31,7 +31,7 @@ export declare const ProtocolToVmAbi: {
     readonly 6: {
         readonly 'contract-create': {
             readonly vmVersion: readonly [
-                VmVersion.Fate2
+                VmVersion.Fate3
             ];
             readonly abiVersion: readonly [
                 AbiVersion.Fate