@aeternity/aepp-sdk 13.0.1 → 13.2.0

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

@@ -217,7 +217,7 @@ export declare const txSchema: readonly [
             deserialize: (value: Buffer) => `ak_${string}` | `nm_${string}`;
         };
         readonly amount: {
-            serializeAettos(value: string | undefined): string;
+            serializeAettos(value: string | undefined, params: {}): string;
             serialize(value: import("./constants").Int | undefined, params: {}, { denomination }: {
                 denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
             }): Buffer;
@@ -656,7 +656,7 @@ export declare const txSchema: readonly [
             serialize(value: import("./constants").Int | undefined, options: {}, parameters: {
                 denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
             }): Buffer;
-            serializeAettos(value: string | undefined): string;
+            serializeAettos(value: string | undefined, params: {}): string;
             deserialize(value: Buffer): string;
         };
     },
@@ -727,11 +727,11 @@ export declare const txSchema: readonly [
             serialize(value: import("./constants").Int | undefined, options: {}, parameters: {
                 denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
             }): Buffer;
-            serializeAettos(value: string | undefined): string;
+            serializeAettos(value: string | undefined, params: {}): string;
             deserialize(value: Buffer): string;
         };
         readonly amount: {
-            serializeAettos(value: string | undefined): string;
+            serializeAettos(value: string | undefined, params: {}): string;
             serialize(value: import("./constants").Int | undefined, params: {}, { denomination }: {
                 denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
             }): Buffer;
@@ -830,7 +830,7 @@ export declare const txSchema: readonly [
             deserialize(value: Buffer): number;
         };
         readonly amount: {
-            serializeAettos(value: string | undefined): string;
+            serializeAettos(value: string | undefined, params: {}): string;
             serialize(value: import("./constants").Int | undefined, params: {}, { denomination }: {
                 denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
             }): Buffer;
@@ -936,7 +936,7 @@ export declare const txSchema: readonly [
             deserialize(buffer: Buffer): string;
         };
         readonly queryFee: {
-            serializeAettos(value: string | undefined): string;
+            serializeAettos(value: string | undefined, params: {}): string;
             serialize(value: import("./constants").Int | undefined, params: {}, { denomination }: {
                 denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
             }): Buffer;
@@ -999,7 +999,7 @@ export declare const txSchema: readonly [
             deserialize(buffer: Buffer): string;
         };
         readonly queryFee: {
-            serializeAettos(value: string | undefined): string;
+            serializeAettos(value: string | undefined, params: {}): string;
             serialize(value: import("./constants").Int | undefined, params: {}, { denomination }: {
                 denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
             }): Buffer;
@@ -1145,7 +1145,7 @@ export declare const txSchema: readonly [
             deserialize(buffer: Buffer): string;
         };
         readonly queryFee: {
-            serializeAettos(value: string | undefined): string;
+            serializeAettos(value: string | undefined, params: {}): string;
             serialize(value: import("./constants").Int | undefined, params: {}, { denomination }: {
                 denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
             }): Buffer;
@@ -2982,7 +2982,7 @@ export declare const txSchema: readonly [
             constValueOptional: boolean;
         };
         readonly fee: {
-            serializeAettos(value: string | undefined): string;
+            serializeAettos(value: string | undefined, params: {}): string;
             serialize(value: import("./constants").Int | undefined, params: {}, { denomination }: {
                 denomination?: import("../..").AE_AMOUNT_FORMATS | undefined;
             }): Buffer;

package/types-legacy/ts4.2/utils/crypto.d.ts

@@ -74,6 +74,7 @@ export declare function sign(data: string | Uint8Array, privateKey: string | Uin
  * @returns is data was signed by address
  */
 export declare function verify(data: Uint8Array, signature: Uint8Array, address: Encoded.AccountAddress): boolean;
+export declare const messagePrefixLength: Buffer;
 export declare function messageToHash(message: string): Buffer;
 export declare function signMessage(message: string, privateKey: string | Buffer): Uint8Array;
 /**

package/types-legacy/ts4.2/utils/errors.d.ts

@@ -240,11 +240,11 @@ export declare class UnexpectedChannelMessageError extends ChannelError {
  * @category exception
  */
 export declare class ChannelIncomingMessageError extends ChannelError {
-    handlerError: BaseError;
+    handlerError: Error;
     incomingMessage: {
         [key: string]: any;
     };
-    constructor(handlerError: BaseError, incomingMessage: {
+    constructor(handlerError: Error, incomingMessage: {
         [key: string]: any;
     });
 }

package/types-legacy/ts4.2/utils/other.d.ts

@@ -29,3 +29,4 @@ export declare function isKeyOfObject<T extends object>(key: string | number | s
 export declare function isItemOfArray<T>(item: any, array: readonly T[]): item is T;
 export declare function isAccountNotFoundError(error: Error): boolean;
 export type UnionToIntersection<Union> = (Union extends any ? (k: Union) => void : never) extends ((k: infer Intersection) => void) ? Intersection : never;
+export declare function ensureError(error: unknown): asserts error is Error;

package/types-legacy/ts4.2/utils/typed-data.d.ts

@@ -0,0 +1,60 @@
+/// <reference types="node" />
+import { Encoded } from './encoder';
+/**
+ * Hashes arbitrary object, can be used to inline the aci hash to contract source code
+ */
+export declare function hashJson(data: unknown): Buffer;
+export type AciValue = 'void' | 'unit' | 'int' | 'bool' | 'string' | 'bits' | 'hash' | 'signature' | 'address' | 'contract_pubkey' | 'Chain.ttl' | 'Chain.ga_meta_tx' | 'Chain.paying_for_tx' | 'Chain.base_tx' | 'AENS.pointee' | 'AENS.name' | 'MCL_BLS12_381.fr' | 'MCL_BLS12_381.fp' | {
+    'Set.set': readonly [
+        AciValue
+    ];
+} | {
+    bytes: number;
+} | {
+    list: readonly [
+        AciValue
+    ];
+} | {
+    map: readonly [
+        AciValue,
+        AciValue
+    ];
+} | {
+    tuple: readonly AciValue[];
+} | {
+    record: ReadonlyArray<{
+        name: string;
+        type: AciValue;
+    }>;
+} | {
+    variant: ReadonlyArray<{
+        [key: string]: readonly AciValue[];
+    }>;
+} | {
+    option: readonly [
+        AciValue
+    ];
+} | {
+    oracle: readonly [
+        AciValue,
+        AciValue
+    ];
+} | {
+    oracle_query: readonly [
+        AciValue,
+        AciValue
+    ];
+};
+export interface Domain {
+    name?: string;
+    version?: number;
+    networkId?: string;
+    contractAddress?: Encoded.ContractAddress;
+}
+export declare function encodeFateValue(value: unknown, aci: AciValue): Encoded.ContractBytearray;
+export declare function decodeFateValue(value: Encoded.ContractBytearray, aci: AciValue): Encoded.ContractBytearray;
+/**
+ * Hashes domain object, can be used to inline domain hash to contract source code
+ */
+export declare function hashDomain(domain: Domain): Buffer;
+export declare function hashTypedData(data: Encoded.ContractBytearray, aci: AciValue, domain: Domain): Buffer;

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

@@ -2,7 +2,8 @@ import Node from './Node';
 import AccountBase from './account/Base';
 import { Encoded } from './utils/encoder';
 import CompilerBase from './contract/compiler/Base';
-import AeSdkMethods, { OnAccount } from './AeSdkMethods';
+import AeSdkMethods, { OnAccount, AeSdkMethodsOptions } from './AeSdkMethods';
+import { AensName } from './tx/builder/constants';
 type NodeInfo = Awaited<ReturnType<Node['getNodeInfo']>> & {
     name: string;
 };
@@ -19,7 +20,7 @@ export default class AeSdkBase extends AeSdkMethods {
      * @param options - Options
      * @param options.nodes - Array of nodes
      */
-    constructor({ nodes, ...options }?: ConstructorParameters<typeof AeSdkMethods>[0] & {
+    constructor({ nodes, ...options }?: AeSdkMethodsOptions & {
         nodes?: Array<{
             name: string;
             instance: Node;
@@ -72,6 +73,11 @@ export default class AeSdkBase extends AeSdkMethods {
      */
     getNodesInPool(): Promise<NodeInfo[]>;
     addresses(): Encoded.AccountAddress[];
+    /**
+     * Resolves an account
+     * @param account - ak-address, instance of AccountBase, or keypair
+     */
+    _resolveAccount(account?: OnAccount): AccountBase;
     get address(): Encoded.AccountAddress;
     sign(data: string | Uint8Array, { onAccount, ...options }?: {
         onAccount?: OnAccount;
@@ -82,7 +88,19 @@ export default class AeSdkBase extends AeSdkMethods {
     signMessage(message: string, { onAccount, ...options }?: {
         onAccount?: OnAccount;
     } & Parameters<AccountBase['signMessage']>[1]): Promise<Uint8Array>;
-    _getOptions(): {
+    signTypedData(data: Encoded.ContractBytearray, aci: Parameters<AccountBase['signTypedData']>[1], { onAccount, ...options }?: {
+        onAccount?: OnAccount;
+    } & Parameters<AccountBase['signTypedData']>[2]): Promise<Encoded.Signature>;
+    signDelegationToContract(contractAddress: Encoded.ContractAddress, { onAccount, ...options }?: {
+        onAccount?: OnAccount;
+    } & Parameters<AccountBase['signDelegationToContract']>[1]): Promise<Encoded.Signature>;
+    signNameDelegationToContract(contractAddress: Encoded.ContractAddress, name: AensName, { onAccount, ...options }?: {
+        onAccount?: OnAccount;
+    } & Parameters<AccountBase['signNameDelegationToContract']>[2]): Promise<Encoded.Signature>;
+    signOracleQueryDelegationToContract(contractAddress: Encoded.ContractAddress, oracleQueryId: Encoded.OracleQueryId, { onAccount, ...options }?: {
+        onAccount?: OnAccount;
+    } & Parameters<AccountBase['signOracleQueryDelegationToContract']>[2]): Promise<Encoded.Signature>;
+    _getOptions(callOptions?: AeSdkMethodsOptions): {
         onNode: Node;
         onAccount: AccountBase;
         onCompiler: CompilerBase;

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

@@ -10,8 +10,9 @@ import Node from './Node';
 import { TxParamsAsync } from './tx/builder/schema.generated';
 import AccountBase from './account/Base';
 import { Encoded } from './utils/encoder';
+import CompilerBase from './contract/compiler/Base';
 export type OnAccount = Encoded.AccountAddress | AccountBase | undefined;
-export declare function getValueOrErrorProxy<Value extends object>(valueCb: () => Value): Value;
+export declare function getValueOrErrorProxy<Value extends object | undefined>(valueCb: () => Value): NonNullable<Value>;
 declare const methods: {
     readonly createGeneralizedAccount: typeof contractGaMethods.createGeneralizedAccount;
     readonly buildAuthTxHash: typeof contractGaMethods.buildAuthTxHash;
@@ -69,11 +70,7 @@ type GetMethodsOptions<Methods extends {
     [Name in keyof Methods]: Methods[Name] extends (...args: infer Args) => any ? Args[Decrement<Args['length']>] : never;
 };
 type MethodsOptions = GetMethodsOptions<typeof methods>;
-interface AeSdkMethodsOptions extends Partial<UnionToIntersection<MethodsOptions[keyof MethodsOptions]>> {
-    nodes?: Array<{
-        name: string;
-        instance: Node;
-    }>;
+export interface AeSdkMethodsOptions extends Partial<UnionToIntersection<MethodsOptions[keyof MethodsOptions]>> {
 }
 /**
  * AeSdkMethods is the composition of:
@@ -94,13 +91,10 @@ declare class AeSdkMethods {
      * @param options - Options
      */
     constructor(options?: AeSdkMethodsOptions);
-    /**
-     * Resolves an account
-     * @param account - ak-address, instance of AccountBase, or keypair
-     */
-    _resolveAccount(account?: OnAccount): AccountBase;
-    _getOptions(): AeSdkMethodsOptions & {
+    _getOptions(callOptions?: AeSdkMethodsOptions): AeSdkMethodsOptions & {
         onAccount: AccountBase;
+        onCompiler: CompilerBase;
+        onNode: Node;
     };
     buildTx(options: TxParamsAsync): Promise<Encoded.Transaction>;
     initializeContract<Methods extends ContractMethodsBase>(options?: Omit<Parameters<typeof Contract.initialize>[0], 'onNode'> & {
@@ -135,5 +129,6 @@ type TransformMethods<Methods extends {
 };
 interface AeSdkMethodsTransformed extends TransformMethods<typeof methods> {
 }
-declare const _default: new (options?: ConstructorParameters<typeof AeSdkMethods>[0]) => AeSdkMethods & AeSdkMethodsTransformed;
-export default _default;
+type AeSdkMethodsTyped = AeSdkMethods & AeSdkMethodsTransformed;
+declare const AeSdkMethodsTyped: new (options?: AeSdkMethodsOptions) => AeSdkMethodsTyped;
+export default AeSdkMethodsTyped;

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

@@ -49,6 +49,7 @@ export default class AeSdkWallet extends AeSdk {
         onDisconnect: OnDisconnect;
         onAskAccounts: OnAskAccounts;
     } & ConstructorParameters<typeof AeSdk>[0]);
+    _getAccountsForClient({ addressSubscription }: RpcClientsInfo): Accounts;
     _pushAccountsToApps(): void;
     selectAccount(address: Encoded.AccountAddress): void;
     addAccount(account: AccountBase, options?: Parameters<AeSdk['addAccount']>[1]): void;
@@ -57,7 +58,6 @@ export default class AeSdkWallet extends AeSdk {
     };
     selectNode(name: string): Promise<void>;
     _getClient(clientId: string): RpcClientsInfo;
-    _isRpcClientSubscribed(clientId: string): boolean;
     _isRpcClientConnected(clientId: string): boolean;
     _disconnectRpcClient(clientId: string): void;
     /**

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

@@ -0,0 +1,46 @@
+import { Middleware as MiddlewareApi, MiddlewareOptionalParams } from './apis/middleware';
+import { Encoded } from './utils/encoder';
+import { ConsensusProtocolVersion } from './tx/builder/constants';
+declare const bigIntPropertyNames: readonly [
+];
+declare const numberPropertyNames: readonly [
+];
+type BigIntPropertyNames = typeof bigIntPropertyNames[number];
+type NumberPropertyNames = typeof numberPropertyNames[number];
+type PreserveOptional<NewType, OrigType> = OrigType extends undefined ? NewType | undefined : NewType;
+export type TransformMiddlewareType<Type> = Type extends (...args: infer Args) => infer Ret ? (...args: TransformMiddlewareType<Args>) => TransformMiddlewareType<Ret> : Type extends [
+    infer Item,
+    ...infer Rest
+] ? [
+    TransformMiddlewareType<Item>,
+    ...TransformMiddlewareType<Rest>
+] : Type extends Array<infer Item> ? Array<TransformMiddlewareType<Item>> : Type extends Promise<infer T> ? Promise<TransformMiddlewareType<T>> : Type extends {
+    [P in any]: any;
+} ? {
+    [Property in keyof Type]: Property extends BigIntPropertyNames ? PreserveOptional<bigint, Type[Property]> : Property extends NumberPropertyNames ? PreserveOptional<number, Type[Property]> : Property extends 'txHash' ? PreserveOptional<Encoded.TxHash, Type[Property]> : Property extends 'bytecode' ? PreserveOptional<Encoded.ContractBytearray, Type[Property]> : TransformMiddlewareType<Type[Property]>;
+} : Type;
+type MiddlewareTransformedApi = new (...args: ConstructorParameters<typeof MiddlewareApi>) => {
+    [Name in keyof InstanceType<typeof MiddlewareApi>]: Name extends 'pipeline' | 'sendRequest' | 'sendOperationRequest' ? MiddlewareApi[Name] : TransformMiddlewareType<MiddlewareApi[Name]>;
+};
+export interface MiddlewareInfo {
+    url: string;
+    nodeNetworkId: string;
+    version: string;
+    consensusProtocolVersion: ConsensusProtocolVersion;
+}
+declare const Middleware_base: MiddlewareTransformedApi;
+export default class Middleware extends Middleware_base {
+    /**
+     * @param url - Url for middleware API
+     * @param options - Options
+     * @param options.ignoreVersion - Don't check node version
+     * @param options.retryCount - Amount of extra requests to do in case of failure
+     * @param options.retryOverallDelay - Time in ms to wait between all retries
+     */
+    constructor(url: string, { ignoreVersion, retryCount, retryOverallDelay, ...options }?: MiddlewareOptionalParams & {
+        ignoreVersion?: boolean;
+        retryCount?: number;
+        retryOverallDelay?: number;
+    });
+}
+export {};

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

@@ -0,0 +1,30 @@
+/// <reference types="ws" />
+import WebSocket from 'isomorphic-ws';
+import { BaseError } from './utils/errors';
+import { Encoded } from './utils/encoder';
+export declare class MiddlewareSubscriberError extends BaseError {
+    constructor(message: string);
+}
+export declare class MiddlewareSubscriberDisconnected extends MiddlewareSubscriberError {
+    readonly closeEvent: WebSocket.CloseEvent;
+    constructor(closeEvent: WebSocket.CloseEvent);
+}
+export default class MiddlewareSubscriber {
+    #private;
+    readonly url: string;
+    get webSocket(): WebSocket | undefined;
+    constructor(url: string);
+    reconnect(): Promise<void>;
+    subscribeKeyBlocks(cb: (p?: any, e?: Error) => void): () => void;
+    subscribeKeyBlocksNode(cb: (p?: any, e?: Error) => void): () => void;
+    subscribeKeyBlocksAll(cb: (p?: any, e?: Error) => void): () => void;
+    subscribeMicroBlocks(cb: (p?: any, e?: Error) => void): () => void;
+    subscribeMicroBlocksNode(cb: (p?: any, e?: Error) => void): () => void;
+    subscribeMicroBlocksAll(cb: (p?: any, e?: Error) => void): () => void;
+    subscribeTransactions(cb: (p?: any, e?: Error) => void): () => void;
+    subscribeTransactionsNode(cb: (p?: any, e?: Error) => void): () => void;
+    subscribeTransactionsAll(cb: (p?: any, e?: Error) => void): () => void;
+    subscribeObject(target: Encoded.KeyBlockHash | Encoded.Channel | Encoded.ContractAddress | Encoded.OracleAddress | Encoded.OracleQueryId | Encoded.AccountAddress | Encoded.Name | `${string}.chain`, cb: (p?: any, e?: Error) => void): () => void;
+    subscribeObjectNode(target: Encoded.KeyBlockHash | Encoded.Channel | Encoded.ContractAddress | Encoded.OracleAddress | Encoded.OracleQueryId | Encoded.AccountAddress | Encoded.Name | `${string}.chain`, cb: (p?: any, e?: Error) => void): () => void;
+    subscribeObjectAll(target: Encoded.KeyBlockHash | Encoded.Channel | Encoded.ContractAddress | Encoded.OracleAddress | Encoded.OracleQueryId | Encoded.AccountAddress | Encoded.Name | `${string}.chain`, cb: (p?: any, e?: Error) => void): () => void;
+}

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

@@ -55,7 +55,7 @@ export type TransformNodeType<Type> = Type extends (...args: infer Args) => infe
 type NodeTransformedApi = new (...args: ConstructorParameters<typeof NodeApi>) => {
     [Name in keyof InstanceType<typeof NodeApi>]: Name extends 'pipeline' | 'sendRequest' | 'sendOperationRequest' ? NodeApi[Name] : TransformNodeType<NodeApi[Name]>;
 };
-export interface NodeInfo {
+interface NodeInfo {
     url: string;
     nodeNetworkId: string;
     version: string;

package/types-legacy/ts4.5/account/Base.d.ts

@@ -1,7 +1,8 @@
 import { Encoded } from '../utils/encoder';
 import Node from '../Node';
 import CompilerBase from '../contract/compiler/Base';
-import { Int } from '../tx/builder/constants';
+import { AensName, Int } from '../tx/builder/constants';
+import { AciValue, Domain } from '../utils/typed-data';
 interface AuthData {
     fee?: Int;
     gasLimit?: number;
@@ -36,17 +37,70 @@ export default abstract class AccountBase {
      * Sign message
      * @param message - Message to sign
      * @param options - Options
-     * @returns Signature as hex string of Uint8Array
+     * @returns Signature
      */
     abstract signMessage(message: string, options?: {
         aeppOrigin?: string;
         aeppRpcClientId?: string;
     }): Promise<Uint8Array>;
+    /**
+     * Sign typed data
+     * @param type - Type of data to sign
+     * @param data - Encoded data to sign
+     * @param options - Options
+     * @returns Signature
+     */
+    signTypedData(data: Encoded.ContractBytearray, aci: AciValue, options?: Domain & {
+        aeppOrigin?: string;
+        aeppRpcClientId?: string;
+    }): Promise<Encoded.Signature>;
+    /**
+     * Sign delegation of AENS, oracle operations to a contract
+     * @param contractAddress - Address of a contract to delegate permissions to
+     * @param options - Options
+     * @returns Signature
+     */
+    signDelegationToContract(contractAddress: Encoded.ContractAddress, options?: {
+        networkId?: string;
+        aeppOrigin?: string;
+        aeppRpcClientId?: string;
+    }): Promise<Encoded.Signature>;
+    /**
+     * Sign delegation of an AENS name to a contract
+     * @param contractAddress - Address of a contract to delegate permissions to
+     * @param name - AENS name to manage by a contract
+     * @param options - Options
+     * @returns Signature
+     */
+    signNameDelegationToContract(contractAddress: Encoded.ContractAddress, name: AensName, options?: {
+        networkId?: string;
+        aeppOrigin?: string;
+        aeppRpcClientId?: string;
+    }): Promise<Encoded.Signature>;
+    /**
+     * Sign delegation of oracle query to a contract
+     *
+     * Warning! Implementations needs to ensure that decoded oracle query id is not equal to decoded
+     * current account address unless https://github.com/aeternity/aesophia/issues/475 is fixed.
+     *
+     * Warning! Implementations needs to ensure that oracle query and contract exists unless
+     * https://github.com/aeternity/aesophia/issues/474 is fixed.
+     *
+     * @param contractAddress - Address of a contract to delegate permissions to
+     * @param oracleQueryId - Oracle query ID to reply by a contract
+     * @param options - Options
+     * @returns Signature
+     */
+    signOracleQueryDelegationToContract(contractAddress: Encoded.ContractAddress, oracleQueryId: Encoded.OracleQueryId, options?: {
+        networkId?: string;
+        aeppOrigin?: string;
+        aeppRpcClientId?: string;
+    }): Promise<Encoded.Signature>;
     /**
      * Sign data blob
      * @param data - Data blob to sign
      * @param options - Options
-     * @returns Signed data blob
+     * @returns Signature
      */
     abstract sign(data: string | Uint8Array, options?: any): Promise<Uint8Array>;
     /**

package/types-legacy/ts4.5/account/Generalized.d.ts

@@ -12,5 +12,9 @@ export default class AccountGeneralized extends AccountBase {
     constructor(address: Encoded.AccountAddress);
     sign(): Promise<Uint8Array>;
     signMessage(): Promise<Uint8Array>;
+    signTypedData(): Promise<Encoded.Signature>;
+    signDelegationToContract(): Promise<Encoded.Signature>;
+    signNameDelegationToContract(): Promise<Encoded.Signature>;
+    signOracleQueryDelegationToContract(): Promise<Encoded.Signature>;
     signTransaction(tx: Encoded.Transaction, { authData, onCompiler, onNode }: Parameters<AccountBase['signTransaction']>[1]): Promise<Encoded.Transaction>;
 }

package/types-legacy/ts4.5/account/Ledger.d.ts

@@ -20,6 +20,10 @@ export default class AccountLedger extends AccountBase {
      */
     constructor(transport: Transport, index: number, address: Encoded.AccountAddress);
     sign(): Promise<Uint8Array>;
+    signTypedData(): Promise<Encoded.Signature>;
+    signDelegationToContract(): Promise<Encoded.Signature>;
+    signNameDelegationToContract(): Promise<Encoded.Signature>;
+    signOracleQueryDelegationToContract(): Promise<Encoded.Signature>;
     signTransaction(tx: Encoded.Transaction, { innerTx, networkId }?: {
         innerTx?: boolean;
         networkId?: string;

package/types-legacy/ts4.5/account/Memory.d.ts

@@ -1,5 +1,7 @@
 import AccountBase from './Base';
 import { Encoded } from '../utils/encoder';
+import { AciValue } from '../utils/typed-data';
+import { AensName } from '../tx/builder/constants';
 export declare function getBufferToSign(transaction: Encoded.Transaction, networkId: string, innerTx: boolean): Uint8Array;
 /**
  * In-memory account class
@@ -20,4 +22,14 @@ export default class AccountMemory extends AccountBase {
         networkId?: string;
     }): Promise<Encoded.Transaction>;
     signMessage(message: string, options?: any): Promise<Uint8Array>;
+    signTypedData(data: Encoded.ContractBytearray, aci: AciValue, { name, version, networkId, contractAddress, ...options }?: Parameters<AccountBase['signTypedData']>[2]): Promise<Encoded.Signature>;
+    signDelegationToContract(contractAddress: Encoded.ContractAddress, { networkId }?: {
+        networkId?: string;
+    }): Promise<Encoded.Signature>;
+    signNameDelegationToContract(contractAddress: Encoded.ContractAddress, name: AensName, { networkId }?: {
+        networkId?: string;
+    }): Promise<Encoded.Signature>;
+    signOracleQueryDelegationToContract(contractAddress: Encoded.ContractAddress, oracleQueryId: Encoded.OracleQueryId, { networkId }?: {
+        networkId?: string;
+    }): Promise<Encoded.Signature>;
 }

package/types-legacy/ts4.5/account/Rpc.d.ts

@@ -2,6 +2,7 @@ import AccountBase from './Base';
 import { Encoded } from '../utils/encoder';
 import RpcClient from '../aepp-wallet-communication/rpc/RpcClient';
 import { AeppApi, WalletApi } from '../aepp-wallet-communication/rpc/types';
+import { AensName } from '../tx/builder/constants';
 /**
  * Account provided by wallet
  * @param params - Params
@@ -14,12 +15,10 @@ export default class AccountRpc extends AccountBase {
     readonly address: Encoded.AccountAddress;
     constructor(rpcClient: RpcClient<WalletApi, AeppApi>, address: Encoded.AccountAddress);
     sign(): Promise<Uint8Array>;
-    /**
-     * @returns Signed transaction
-     */
     signTransaction(tx: Encoded.Transaction, { innerTx, networkId }?: Parameters<AccountBase['signTransaction']>[1]): Promise<Encoded.Transaction>;
-    /**
-     * @returns Signed message
-     */
     signMessage(message: string): Promise<Uint8Array>;
+    signTypedData(data: Encoded.ContractBytearray, aci: Parameters<AccountBase['signTypedData']>[1], { name, version, contractAddress, networkId, }?: Parameters<AccountBase['signTypedData']>[2]): Promise<Encoded.Signature>;
+    signDelegationToContract(contractAddress: Encoded.ContractAddress): Promise<Encoded.Signature>;
+    signNameDelegationToContract(contractAddress: Encoded.ContractAddress, name: AensName): Promise<Encoded.Signature>;
+    signOracleQueryDelegationToContract(contractAddress: Encoded.ContractAddress, oracleQueryId: Encoded.OracleQueryId): Promise<Encoded.Signature>;
 }

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

@@ -211,7 +211,7 @@ interface AensPreclaimOptions extends BuildTxOptions<Tag.NamePreclaimTx, 'accoun
  * @example
  * ```js
  * const name = 'test.chain'
- * const bidFee = computeBidFee(name, startFee, incrementPercentage)
+ * const bidFee = computeBidFee(name, { startFee, increment: 0.42 })
  *
  * await sdkInstance.aensBid(name, 213109412839123, { ttl, fee, nonce })
  * ```

package/types-legacy/ts4.5/aepp-wallet-communication/rpc/types.d.ts

@@ -1,7 +1,9 @@
 import { Encoded } from '../../utils/encoder';
+import { Domain, AciValue } from '../../utils/typed-data';
 import { METHODS, SUBSCRIPTION_TYPES, WALLET_TYPE } from '../schema';
 import { TransformNodeType } from '../../Node';
 import { SignedTx } from '../../apis/node';
+import { AensName } from '../../tx/builder/constants';
 export interface WalletInfo {
     id: string;
     name: string;
@@ -60,6 +62,7 @@ export interface WalletApi {
          * @see {@link https://github.com/aeternity/aepp-sdk-js/commit/153fd89a52c4eab39fcd659b356b36d32129c1ba}
          */
         networkId: string;
+        innerTx?: boolean;
     }) => Promise<{
         /**
          * @deprecated this is not a hash at all, will be removed later at the same time
@@ -77,6 +80,22 @@ export interface WalletApi {
     }) => Promise<{
         signature: string;
     }>;
+    [METHODS.signTypedData]: (p: {
+        domain: Domain;
+        aci: AciValue;
+        data: Encoded.ContractBytearray;
+        onAccount: Encoded.AccountAddress;
+    }) => Promise<{
+        signature: Encoded.Signature;
+    }>;
+    [METHODS.signDelegationToContract]: (p: {
+        contractAddress: Encoded.ContractAddress;
+        name?: AensName;
+        oracleQueryId?: Encoded.OracleQueryId;
+        onAccount: Encoded.AccountAddress;
+    }) => Promise<{
+        signature: Encoded.Signature;
+    }>;
 }
 export interface AeppApi {
     [METHODS.updateAddress]: (a: Accounts) => void;

package/types-legacy/ts4.5/aepp-wallet-communication/schema.d.ts

@@ -31,6 +31,8 @@ export declare const enum METHODS {
     connect = "connection.open",
     sign = "transaction.sign",
     signMessage = "message.sign",
+    signTypedData = "typedData.sign",
+    signDelegationToContract = "delegationToContract.sign",
     subscribeAddress = "address.subscribe",
     updateNetwork = "networkId.update",
     closeConnection = "connection.close"
@@ -66,14 +68,6 @@ export declare class RpcInvalidTransactionError extends RpcError {
     code: number;
     constructor(data?: any);
 }
-/**
- * @category exception
- */
-export declare class RpcBroadcastError extends RpcError {
-    static code: number;
-    code: number;
-    constructor(data?: any);
-}
 /**
  * @category exception
  */

package/types-legacy/ts4.5/aepp-wallet-communication/wallet-detector.d.ts

@@ -20,6 +20,6 @@ interface Wallets {
  */
 declare const _default: (connection: BrowserConnection, onDetected: ({ wallets, newWallet }: {
     wallets: Wallets;
-    newWallet?: Wallet | undefined;
+    newWallet: Wallet;
 }) => void) => () => void;
 export default _default;

package/types-legacy/ts4.5/apis/compiler/models/index.d.ts

@@ -9,12 +9,6 @@ export interface CompileOpts {
     /** Name of contract source file - only used in error messages */
     srcFile?: string;
 }
-export interface Aci {
-    /** Any object */
-    encodedAci: Record<string, unknown>;
-    externalEncodedAci?: Record<string, unknown>[];
-    interface: string;
-}
 export interface CompilerError {
     type: string;
     pos: ErrorPos;
@@ -127,7 +121,7 @@ export interface SophiaJsonData {
 export interface GenerateACIOptionalParams extends coreClient.OperationOptions {
 }
 /** Contains response data for the generateACI operation. */
-export type GenerateACIResponse = Aci;
+export type GenerateACIResponse = Record<string, unknown>[];
 /** Optional parameters. */
 export interface CompileContractOptionalParams extends coreClient.OperationOptions {
 }

package/types-legacy/ts4.5/apis/compiler/models/mappers.d.ts

@@ -1,7 +1,6 @@
 import * as coreClient from "@azure/core-client";
 export declare const Contract: coreClient.CompositeMapper;
 export declare const CompileOpts: coreClient.CompositeMapper;
-export declare const Aci: coreClient.CompositeMapper;
 export declare const CompilerError: coreClient.CompositeMapper;
 export declare const ErrorPos: coreClient.CompositeMapper;
 export declare const CompileResult: coreClient.CompositeMapper;

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

@@ -0,0 +1,2 @@
+export * from "./models";
+export { Middleware } from "./middleware";