@aeternity/aepp-sdk 13.0.0 → 13.1.0

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

@@ -2,7 +2,7 @@ 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';
 type NodeInfo = Awaited<ReturnType<Node['getNodeInfo']>> & {
     name: string;
 };
@@ -19,7 +19,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 +72,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 +87,10 @@ 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>;
+    _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/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

@@ -2,6 +2,7 @@ import { Encoded } from '../utils/encoder';
 import Node from '../Node';
 import CompilerBase from '../contract/compiler/Base';
 import { Int } from '../tx/builder/constants';
+import { AciValue, Domain } from '../utils/typed-data';
 interface AuthData {
     fee?: Int;
     gasLimit?: number;
@@ -36,17 +37,28 @@ 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
+     */
+    abstract signTypedData(data: Encoded.ContractBytearray, aci: AciValue, options?: Domain & {
+        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,6 @@ export default class AccountGeneralized extends AccountBase {
     constructor(address: Encoded.AccountAddress);
     sign(): Promise<Uint8Array>;
     signMessage(): Promise<Uint8Array>;
+    signTypedData(): 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,7 @@ export default class AccountLedger extends AccountBase {
      */
     constructor(transport: Transport, index: number, address: Encoded.AccountAddress);
     sign(): Promise<Uint8Array>;
+    signTypedData(): 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,6 @@
 import AccountBase from './Base';
 import { Encoded } from '../utils/encoder';
+import { AciValue } from '../utils/typed-data';
 export declare function getBufferToSign(transaction: Encoded.Transaction, networkId: string, innerTx: boolean): Uint8Array;
 /**
  * In-memory account class
@@ -20,4 +21,5 @@ 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>;
 }

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

@@ -14,12 +14,7 @@ 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>;
 }

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,4 +1,5 @@
 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';
@@ -60,6 +61,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 +79,14 @@ export interface WalletApi {
     }) => Promise<{
         signature: string;
     }>;
+    [METHODS.signTypedData]: (p: {
+        domain: Domain;
+        aci: AciValue;
+        data: Encoded.ContractBytearray;
+        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,7 @@ export declare const enum METHODS {
     connect = "connection.open",
     sign = "transaction.sign",
     signMessage = "message.sign",
+    signTypedData = "typedData.sign",
     subscribeAddress = "address.subscribe",
     updateNetwork = "networkId.update",
     closeConnection = "connection.close"
@@ -66,14 +67,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";