LaconicNetwork/cosmjs-util
10
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

Rename *Module to *Extension

Browse Source
This commit is contained in:
Simon Warta 2020-07-07 23:51:59 +02:00
parent e42620bf70
commit f047df1af0
18 changed files with 247 additions and 235 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
packages/cosmwasm/src/lcdapi/wasm.spec.ts
View File

@ -2,7 +2,7 @@
import { Sha256 } from "@cosmjs/crypto";
import { Bech32, fromAscii, fromBase64, fromHex, toAscii, toBase64, toHex } from "@cosmjs/encoding";
import {
AuthModule,
AuthExtension,
Coin,
coin,
coins,
@ -11,7 +11,7 @@ import {
Pen,
PostTxsResponse,
Secp256k1Pen,
setupAuthModule,
setupAuthExtension,
StdFee,
} from "@cosmjs/sdk38";
import { assert } from "@cosmjs/utils";
@ -37,12 +37,12 @@ import {
wasmd,
wasmdEnabled,
} from "../testutils.spec";
import { setupWasmModule, WasmModule } from "./wasm";
import { setupWasmModule, WasmExtension } from "./wasm";
type WasmClient = LcdClient & AuthModule & WasmModule;
type WasmClient = LcdClient & AuthExtension & WasmExtension;
function makeWasmClient(apiUrl: string): WasmClient {
return LcdClient.withModules({ apiUrl }, setupAuthModule, setupWasmModule);
return LcdClient.withExtensions({ apiUrl }, setupAuthExtension, setupWasmModule);
}
async function uploadContract(

6
packages/cosmwasm/src/lcdapi/wasm.ts
View File

@ -1,5 +1,5 @@
import { fromBase64, fromUtf8, toHex, toUtf8 } from "@cosmjs/encoding";
import { LcdApiArray, LcdClient, LcdModule, normalizeLcdApiArray } from "@cosmjs/sdk38";
import { LcdApiArray, LcdClient, LcdExtension, normalizeLcdApiArray } from "@cosmjs/sdk38";
import { JsonObject, Model, parseWasmData, WasmData } from "../types";
@ -75,7 +75,7 @@ function unwrapWasmResponse<T>(response: WasmResponse<T>): T {
/**
* @see https://github.com/cosmwasm/wasmd/blob/master/x/wasm/client/rest/query.go#L19-L27
*/
export interface WasmModule extends LcdModule {
export interface WasmExtension extends LcdExtension {
readonly wasm: {
readonly listCodeInfo: () => Promise<readonly CodeInfo[]>;
@ -113,7 +113,7 @@ export interface WasmModule extends LcdModule {
};
}
export function setupWasmModule(base: LcdClient): WasmModule {
export function setupWasmModule(base: LcdClient): WasmExtension {
return {
wasm: {
listCodeInfo: async () => {

6
packages/cosmwasm/types/lcdapi/wasm.d.ts vendored
View File

@ -1,4 +1,4 @@
import { LcdClient, LcdModule } from "@cosmjs/sdk38";
import { LcdClient, LcdExtension } from "@cosmjs/sdk38";
import { JsonObject, Model } from "../types";
export interface CodeInfo {
readonly id: number;
@ -40,7 +40,7 @@ export interface ContractDetails extends ContractInfo {
/**
* @see https://github.com/cosmwasm/wasmd/blob/master/x/wasm/client/rest/query.go#L19-L27
*/
export interface WasmModule extends LcdModule {
export interface WasmExtension extends LcdExtension {
readonly wasm: {
readonly listCodeInfo: () => Promise<readonly CodeInfo[]>;
/**
@ -71,4 +71,4 @@ export interface WasmModule extends LcdModule {
readonly queryContractSmart: (address: string, query: object) => Promise<JsonObject>;
};
}
export declare function setupWasmModule(base: LcdClient): WasmModule;
export declare function setupWasmModule(base: LcdClient): WasmExtension;

11
packages/sdk38/src/cosmosclient.ts
View File

@ -3,7 +3,7 @@ import { fromBase64, fromHex, toHex } from "@cosmjs/encoding";
import { Uint53 } from "@cosmjs/math";
import { Coin } from "./coins";
import { AuthModule, BroadcastMode, LcdClient, setupAuthModule } from "./lcdapi";
import { AuthExtension, BroadcastMode, LcdClient, setupAuthExtension } from "./lcdapi";
import { Log, parseLogs } from "./logs";
import { decodeBech32Pubkey } from "./pubkey";
import { CosmosSdkTx, PubKey, StdTx } from "./types";
@ -130,11 +130,11 @@ export interface Block {
/** Use for testing only */
export interface PrivateCosmWasmClient {
readonly lcdClient: LcdClient & AuthModule;
readonly lcdClient: LcdClient & AuthExtension;
}
export class CosmosClient {
protected readonly lcdClient: LcdClient & AuthModule;
protected readonly lcdClient: LcdClient & AuthExtension;
/** Any address the chain considers valid (valid bech32 with proper prefix) */
protected anyValidAddress: string | undefined;
@ -150,7 +150,10 @@ export class CosmosClient {
* @param broadcastMode Defines at which point of the transaction processing the postTx method (i.e. transaction broadcasting) returns
*/
public constructor(apiUrl: string, broadcastMode = BroadcastMode.Block) {
this.lcdClient = LcdClient.withModules({ apiUrl: apiUrl, broadcastMode: broadcastMode }, setupAuthModule);
this.lcdClient = LcdClient.withExtensions(
{ apiUrl: apiUrl, broadcastMode: broadcastMode },
setupAuthExtension,
);
}
public async getChainId(): Promise<string> {

10
packages/sdk38/src/index.ts
View File

@ -22,20 +22,20 @@ export {
export { makeSignBytes } from "./encoding";
export {
AuthAccountsResponse,
AuthModule,
AuthExtension,
BlockResponse,
BroadcastMode,
EncodeTxResponse,
LcdApiArray,
LcdExtension,
LcdClient,
LcdModule,
NodeInfoResponse,
normalizeLcdApiArray,
PostTxsResponse,
SearchTxsResponse,
setupAuthModule,
setupSupplyModule,
SupplyModule,
setupAuthExtension,
setupSupplyExtension,
SupplyExtension,
TxsResponse,
} from "./lcdapi";
export { RestClient } from "./restclient";

8
packages/sdk38/src/lcdapi/auth.spec.ts
View File

@ -8,14 +8,14 @@ import {
unused,
wasmd,
} from "../testutils.spec";
import { AuthModule, setupAuthModule } from "./auth";
import { AuthExtension, setupAuthExtension } from "./auth";
import { LcdClient } from "./lcdclient";
function makeAuthClient(apiUrl: string): LcdClient & AuthModule {
return LcdClient.withModules({ apiUrl }, setupAuthModule);
function makeAuthClient(apiUrl: string): LcdClient & AuthExtension {
return LcdClient.withExtensions({ apiUrl }, setupAuthExtension);
}
describe("auth", () => {
describe("AuthExtension", () => {
it("works for unused account without pubkey", async () => {
pendingWithoutWasmd();
const client = makeAuthClient(wasmd.endpoint);

6
packages/sdk38/src/lcdapi/auth.ts
View File

@ -1,5 +1,5 @@
import { Coin } from "../coins";
import { LcdClient, LcdModule } from "./lcdclient";
import { LcdClient, LcdExtension } from "./lcdclient";
export interface CosmosSdkAccount {
/** Bech32 account address */
@ -19,13 +19,13 @@ export interface AuthAccountsResponse {
};
}
export interface AuthModule extends LcdModule {
export interface AuthExtension extends LcdExtension {
readonly auth: {
readonly account: (address: string) => Promise<AuthAccountsResponse>;
};
}
export function setupAuthModule(base: LcdClient): AuthModule {
export function setupAuthExtension(base: LcdClient): AuthExtension {
return {
auth: {
account: async (address: string) => {

6
packages/sdk38/src/lcdapi/index.ts
View File

@ -2,8 +2,8 @@
// Standard modules (see tracking issue https://github.com/CosmWasm/cosmjs/issues/276)
//
export { AuthModule, AuthAccountsResponse, setupAuthModule } from "./auth";
export { setupSupplyModule, SupplyModule, TotalSupplyAllReponse, TotalSupplyReponse } from "./supply";
export { AuthExtension, AuthAccountsResponse, setupAuthExtension } from "./auth";
export { setupSupplyExtension, SupplyExtension, TotalSupplyAllReponse, TotalSupplyReponse } from "./supply";
//
// Base types
@ -18,4 +18,4 @@ export {
SearchTxsResponse,
TxsResponse,
} from "./base";
export { LcdApiArray, LcdClient, LcdModule, normalizeLcdApiArray } from "./lcdclient";
export { LcdApiArray, LcdClient, LcdExtension, normalizeLcdApiArray } from "./lcdclient";

30
packages/sdk38/src/lcdapi/lcdclient.spec.ts
View File

@ -21,9 +21,9 @@ import {
wasmdEnabled,
} from "../testutils.spec";
import { StdFee } from "../types";
import { setupAuthModule } from "./auth";
import { setupAuthExtension } from "./auth";
import { TxsResponse } from "./base";
import { LcdApiArray, LcdClient, LcdModule, normalizeLcdApiArray } from "./lcdclient";
import { LcdApiArray, LcdClient, LcdExtension, normalizeLcdApiArray } from "./lcdclient";
/** Deployed as part of scripts/wasmd/init.sh */
export const deployedErc20 = {
@ -79,13 +79,13 @@ describe("LcdClient", () => {
return response.result;
}
interface WasmModule extends LcdModule {
interface WasmExtension extends LcdExtension {
wasm: {
listCodeInfo: () => Promise<readonly CodeInfo[]>;
};
}
function setupWasmModule(base: LcdClient): WasmModule {
function setupWasmExtension(base: LcdClient): WasmExtension {
return {
wasm: {
listCodeInfo: async (): Promise<readonly CodeInfo[]> => {
@ -98,14 +98,14 @@ describe("LcdClient", () => {
}
it("works for no modules", async () => {
const client = LcdClient.withModules({ apiUrl: wasmd.endpoint });
const client = LcdClient.withExtensions({ apiUrl: wasmd.endpoint });
expect(client).toBeTruthy();
});
it("works for one module", async () => {
pendingWithoutWasmd();
const client = LcdClient.withModules({ apiUrl: wasmd.endpoint }, setupWasmModule);
const client = LcdClient.withExtensions({ apiUrl: wasmd.endpoint }, setupWasmExtension);
const codes = await client.wasm.listCodeInfo();
expect(codes.length).toBeGreaterThanOrEqual(3);
expect(codes[0].id).toEqual(deployedErc20.codeId);
@ -134,7 +134,11 @@ describe("LcdClient", () => {
};
}
const client = LcdClient.withModules({ apiUrl: wasmd.endpoint }, setupWasmModule, setupSupplyModule);
const client = LcdClient.withExtensions(
{ apiUrl: wasmd.endpoint },
setupWasmExtension,
setupSupplyModule,
);
const codes = await client.wasm.listCodeInfo();
expect(codes.length).toBeGreaterThanOrEqual(3);
expect(codes[0].id).toEqual(deployedErc20.codeId);
@ -522,7 +526,7 @@ describe("LcdClient", () => {
gas: "890000",
};
const client = LcdClient.withModules({ apiUrl: wasmd.endpoint }, setupAuthModule);
const client = LcdClient.withExtensions({ apiUrl: wasmd.endpoint }, setupAuthExtension);
const { account_number, sequence } = (await client.auth.account(faucet.address)).result.value;
const signBytes = makeSignBytes([theMsg], fee, wasmd.chainId, memo, account_number, sequence);
@ -575,7 +579,7 @@ describe("LcdClient", () => {
gas: "890000",
};
const client = LcdClient.withModules({ apiUrl: wasmd.endpoint }, setupAuthModule);
const client = LcdClient.withExtensions({ apiUrl: wasmd.endpoint }, setupAuthExtension);
const { account_number: an1, sequence: sequence1 } = (await client.auth.account(address1)).result.value;
const { account_number: an2, sequence: sequence2 } = (await client.auth.account(address2)).result.value;
const { account_number: an3, sequence: sequence3 } = (await client.auth.account(address3)).result.value;
@ -640,7 +644,7 @@ describe("LcdClient", () => {
gas: "890000",
};
const client = LcdClient.withModules({ apiUrl: wasmd.endpoint }, setupAuthModule);
const client = LcdClient.withExtensions({ apiUrl: wasmd.endpoint }, setupAuthExtension);
const { account_number, sequence } = (await client.auth.account(address1)).result.value;
const signBytes = makeSignBytes([msg1, msg2], fee, wasmd.chainId, memo, account_number, sequence);
@ -700,7 +704,7 @@ describe("LcdClient", () => {
gas: "890000",
};
const client = LcdClient.withModules({ apiUrl: wasmd.endpoint }, setupAuthModule);
const client = LcdClient.withExtensions({ apiUrl: wasmd.endpoint }, setupAuthExtension);
const { account_number: an1, sequence: sequence1 } = (await client.auth.account(address1)).result.value;
const { account_number: an2, sequence: sequence2 } = (await client.auth.account(address2)).result.value;
@ -768,7 +772,7 @@ describe("LcdClient", () => {
gas: "890000",
};
const client = LcdClient.withModules({ apiUrl: wasmd.endpoint }, setupAuthModule);
const client = LcdClient.withExtensions({ apiUrl: wasmd.endpoint }, setupAuthExtension);
const { account_number: an1, sequence: sequence1 } = (await client.auth.account(address1)).result.value;
const { account_number: an2, sequence: sequence2 } = (await client.auth.account(address2)).result.value;
@ -831,7 +835,7 @@ describe("LcdClient", () => {
gas: "890000",
};
const client = LcdClient.withModules({ apiUrl: wasmd.endpoint }, setupAuthModule);
const client = LcdClient.withExtensions({ apiUrl: wasmd.endpoint }, setupAuthExtension);
const { account_number: an1, sequence: sequence1 } = (await client.auth.account(address1)).result.value;
const { account_number: an2, sequence: sequence2 } = (await client.auth.account(address2)).result.value;

190
packages/sdk38/src/lcdapi/lcdclient.ts
View File

@ -20,9 +20,9 @@ export function normalizeLcdApiArray<T>(backend: LcdApiArray<T>): readonly T[] {
return backend || [];
}
export type LcdModule = Record<string, Record<string, (...args: any[]) => any>>;
export type LcdExtension = Record<string, Record<string, (...args: any[]) => any>>;
type LcdModuleSetup<M extends LcdModule> = (base: LcdClient) => M;
type LcdExtensionSetup<P extends LcdExtension> = (base: LcdClient) => P;
export interface LcdClientBaseOptions {
readonly apiUrl: string;
@ -65,142 +65,142 @@ function parseAxiosError(err: AxiosError): never {
*/
export class LcdClient {
/** Constructs an LCD client with 0 modules */
public static withModules(options: LcdClientBaseOptions): LcdClient;
public static withExtensions(options: LcdClientBaseOptions): LcdClient;
/** Constructs an LCD client with 1 module */
public static withModules<A extends LcdModule>(
public static withExtensions<A extends LcdExtension>(
options: LcdClientBaseOptions,
setupModuleA: LcdModuleSetup<A>,
setupModuleA: LcdExtensionSetup<A>,
): LcdClient & A;
/** Constructs an LCD client with 2 modules */
public static withModules<A extends LcdModule, B extends LcdModule>(
public static withExtensions<A extends LcdExtension, B extends LcdExtension>(
options: LcdClientBaseOptions,
setupModuleA: LcdModuleSetup<A>,
setupModuleB: LcdModuleSetup<B>,
setupModuleA: LcdExtensionSetup<A>,
setupModuleB: LcdExtensionSetup<B>,
): LcdClient & A & B;
/** Constructs an LCD client with 3 modules */
public static withModules<A extends LcdModule, B extends LcdModule, C extends LcdModule>(
public static withExtensions<A extends LcdExtension, B extends LcdExtension, C extends LcdExtension>(
options: LcdClientBaseOptions,
setupModuleA: LcdModuleSetup<A>,
setupModuleB: LcdModuleSetup<B>,
setupModuleC: LcdModuleSetup<C>,
setupModuleA: LcdExtensionSetup<A>,
setupModuleB: LcdExtensionSetup<B>,
setupModuleC: LcdExtensionSetup<C>,
): LcdClient & A & B & C;
/** Constructs an LCD client with 4 modules */
public static withModules<
A extends LcdModule,
B extends LcdModule,
C extends LcdModule,
D extends LcdModule
public static withExtensions<
A extends LcdExtension,
B extends LcdExtension,
C extends LcdExtension,
D extends LcdExtension
>(
options: LcdClientBaseOptions,
setupModuleA: LcdModuleSetup<A>,
setupModuleB: LcdModuleSetup<B>,
setupModuleC: LcdModuleSetup<C>,
setupModuleD: LcdModuleSetup<D>,
setupModuleA: LcdExtensionSetup<A>,
setupModuleB: LcdExtensionSetup<B>,
setupModuleC: LcdExtensionSetup<C>,
setupModuleD: LcdExtensionSetup<D>,
): LcdClient & A & B & C & D;
/** Constructs an LCD client with 5 modules */
public static withModules<
A extends LcdModule,
B extends LcdModule,
C extends LcdModule,
D extends LcdModule,
E extends LcdModule
public static withExtensions<
A extends LcdExtension,
B extends LcdExtension,
C extends LcdExtension,
D extends LcdExtension,
E extends LcdExtension
>(
options: LcdClientBaseOptions,
setupModuleA: LcdModuleSetup<A>,
setupModuleB: LcdModuleSetup<B>,
setupModuleC: LcdModuleSetup<C>,
setupModuleD: LcdModuleSetup<D>,
setupModuleE: LcdModuleSetup<E>,
setupModuleA: LcdExtensionSetup<A>,
setupModuleB: LcdExtensionSetup<B>,
setupModuleC: LcdExtensionSetup<C>,
setupModuleD: LcdExtensionSetup<D>,
setupModuleE: LcdExtensionSetup<E>,
): LcdClient & A & B & C & D & E;
/** Constructs an LCD client with 6 modules */
public static withModules<
A extends LcdModule,
B extends LcdModule,
C extends LcdModule,
D extends LcdModule,
E extends LcdModule,
F extends LcdModule
public static withExtensions<
A extends LcdExtension,
B extends LcdExtension,
C extends LcdExtension,
D extends LcdExtension,
E extends LcdExtension,
F extends LcdExtension
>(
options: LcdClientBaseOptions,
setupModuleA: LcdModuleSetup<A>,
setupModuleB: LcdModuleSetup<B>,
setupModuleC: LcdModuleSetup<C>,
setupModuleD: LcdModuleSetup<D>,
setupModuleE: LcdModuleSetup<E>,
setupModuleF: LcdModuleSetup<F>,
setupModuleA: LcdExtensionSetup<A>,
setupModuleB: LcdExtensionSetup<B>,
setupModuleC: LcdExtensionSetup<C>,
setupModuleD: LcdExtensionSetup<D>,
setupModuleE: LcdExtensionSetup<E>,
setupModuleF: LcdExtensionSetup<F>,
): LcdClient & A & B & C & D & E & F;
/** Constructs an LCD client with 7 modules */
public static withModules<
A extends LcdModule,
B extends LcdModule,
C extends LcdModule,
D extends LcdModule,
E extends LcdModule,
F extends LcdModule,
G extends LcdModule
public static withExtensions<
A extends LcdExtension,
B extends LcdExtension,
C extends LcdExtension,
D extends LcdExtension,
E extends LcdExtension,
F extends LcdExtension,
G extends LcdExtension
>(
options: LcdClientBaseOptions,
setupModuleA: LcdModuleSetup<A>,
setupModuleB: LcdModuleSetup<B>,
setupModuleC: LcdModuleSetup<C>,
setupModuleD: LcdModuleSetup<D>,
setupModuleE: LcdModuleSetup<E>,
setupModuleF: LcdModuleSetup<F>,
setupModuleG: LcdModuleSetup<G>,
setupModuleA: LcdExtensionSetup<A>,
setupModuleB: LcdExtensionSetup<B>,
setupModuleC: LcdExtensionSetup<C>,
setupModuleD: LcdExtensionSetup<D>,
setupModuleE: LcdExtensionSetup<E>,
setupModuleF: LcdExtensionSetup<F>,
setupModuleG: LcdExtensionSetup<G>,
): LcdClient & A & B & C & D & E & F & G;
/** Constructs an LCD client with 8 modules */
public static withModules<
A extends LcdModule,
B extends LcdModule,
C extends LcdModule,
D extends LcdModule,
E extends LcdModule,
F extends LcdModule,
G extends LcdModule,
H extends LcdModule
public static withExtensions<
A extends LcdExtension,
B extends LcdExtension,
C extends LcdExtension,
D extends LcdExtension,
E extends LcdExtension,
F extends LcdExtension,
G extends LcdExtension,
H extends LcdExtension
>(
options: LcdClientBaseOptions,
setupModuleA: LcdModuleSetup<A>,
setupModuleB: LcdModuleSetup<B>,
setupModuleC: LcdModuleSetup<C>,
setupModuleD: LcdModuleSetup<D>,
setupModuleE: LcdModuleSetup<E>,
setupModuleF: LcdModuleSetup<F>,
setupModuleG: LcdModuleSetup<G>,
setupModuleH: LcdModuleSetup<H>,
setupModuleA: LcdExtensionSetup<A>,
setupModuleB: LcdExtensionSetup<B>,
setupModuleC: LcdExtensionSetup<C>,
setupModuleD: LcdExtensionSetup<D>,
setupModuleE: LcdExtensionSetup<E>,
setupModuleF: LcdExtensionSetup<F>,
setupModuleG: LcdExtensionSetup<G>,
setupModuleH: LcdExtensionSetup<H>,
): LcdClient & A & B & C & D & E & F & G & H;
public static withModules<
A extends LcdModule,
B extends LcdModule,
C extends LcdModule,
D extends LcdModule,
E extends LcdModule,
F extends LcdModule,
G extends LcdModule,
H extends LcdModule
public static withExtensions<
A extends LcdExtension,
B extends LcdExtension,
C extends LcdExtension,
D extends LcdExtension,
E extends LcdExtension,
F extends LcdExtension,
G extends LcdExtension,
H extends LcdExtension
>(
options: LcdClientBaseOptions,
setupModuleA?: LcdModuleSetup<A>,
setupModuleB?: LcdModuleSetup<B>,
setupModuleC?: LcdModuleSetup<C>,
setupModuleD?: LcdModuleSetup<D>,
setupModuleE?: LcdModuleSetup<E>,
setupModuleF?: LcdModuleSetup<F>,
setupModuleG?: LcdModuleSetup<G>,
setupModuleH?: LcdModuleSetup<H>,
setupModuleA?: LcdExtensionSetup<A>,
setupModuleB?: LcdExtensionSetup<B>,
setupModuleC?: LcdExtensionSetup<C>,
setupModuleD?: LcdExtensionSetup<D>,
setupModuleE?: LcdExtensionSetup<E>,
setupModuleF?: LcdExtensionSetup<F>,
setupModuleG?: LcdExtensionSetup<G>,
setupModuleH?: LcdExtensionSetup<H>,
): any {
const client = new LcdClient(options.apiUrl, options.broadcastMode);
const modules = new Array<LcdModule>();
const modules = new Array<LcdExtension>();
if (setupModuleA) modules.push(setupModuleA(client));
if (setupModuleB) modules.push(setupModuleB(client));
if (setupModuleC) modules.push(setupModuleC(client));

8
packages/sdk38/src/lcdapi/supply.spec.ts
View File

@ -1,13 +1,13 @@
import { pendingWithoutWasmd, wasmd } from "../testutils.spec";
import { LcdClient } from "./lcdclient";
import { setupSupplyModule } from "./supply";
import { setupSupplyExtension } from "./supply";
describe("supply", () => {
describe("SupplyExtension", () => {
describe("totalAll", () => {
it("works", async () => {
pendingWithoutWasmd();
const client = LcdClient.withModules({ apiUrl: wasmd.endpoint }, setupSupplyModule);
const client = LcdClient.withExtensions({ apiUrl: wasmd.endpoint }, setupSupplyExtension);
const supply = await client.supply.totalAll();
expect(supply).toEqual({
height: jasmine.stringMatching(/^[0-9]+$/),
@ -29,7 +29,7 @@ describe("supply", () => {
it("works", async () => {
pendingWithoutWasmd();
const client = LcdClient.withModules({ apiUrl: wasmd.endpoint }, setupSupplyModule);
const client = LcdClient.withExtensions({ apiUrl: wasmd.endpoint }, setupSupplyExtension);
const supply = await client.supply.total("ucosm");
expect(supply).toEqual({
height: jasmine.stringMatching(/^[0-9]+$/),

6
packages/sdk38/src/lcdapi/supply.ts
View File

@ -1,5 +1,5 @@
import { Coin } from "../coins";
import { LcdApiArray, LcdClient, LcdModule } from "./lcdclient";
import { LcdApiArray, LcdClient, LcdExtension } from "./lcdclient";
export interface TotalSupplyAllReponse {
readonly height: string;
@ -12,14 +12,14 @@ export interface TotalSupplyReponse {
readonly result: string;
}
export interface SupplyModule extends LcdModule {
export interface SupplyExtension extends LcdExtension {
readonly supply: {
readonly totalAll: () => Promise<TotalSupplyAllReponse>;
readonly total: (denom: string) => Promise<TotalSupplyReponse>;
};
}
export function setupSupplyModule(base: LcdClient): SupplyModule {
export function setupSupplyExtension(base: LcdClient): SupplyExtension {
return {
supply: {
totalAll: async () => {

6
packages/sdk38/types/cosmosclient.d.ts vendored
View File

@ -1,5 +1,5 @@
import { Coin } from "./coins";
import { AuthModule, BroadcastMode, LcdClient } from "./lcdapi";
import { AuthExtension, BroadcastMode, LcdClient } from "./lcdapi";
import { Log } from "./logs";
import { CosmosSdkTx, PubKey, StdTx } from "./types";
export interface GetNonceResult {
@ -94,10 +94,10 @@ export interface Block {
}
/** Use for testing only */
export interface PrivateCosmWasmClient {
readonly lcdClient: LcdClient & AuthModule;
readonly lcdClient: LcdClient & AuthExtension;
}
export declare class CosmosClient {
protected readonly lcdClient: LcdClient & AuthModule;
protected readonly lcdClient: LcdClient & AuthExtension;
/** Any address the chain considers valid (valid bech32 with proper prefix) */
protected anyValidAddress: string | undefined;
private chainId;

10
packages/sdk38/types/index.d.ts vendored
View File

@ -20,20 +20,20 @@ export {
export { makeSignBytes } from "./encoding";
export {
AuthAccountsResponse,
AuthModule,
AuthExtension,
BlockResponse,
BroadcastMode,
EncodeTxResponse,
LcdApiArray,
LcdExtension,
LcdClient,
LcdModule,
NodeInfoResponse,
normalizeLcdApiArray,
PostTxsResponse,
SearchTxsResponse,
setupAuthModule,
setupSupplyModule,
SupplyModule,
setupAuthExtension,
setupSupplyExtension,
SupplyExtension,
TxsResponse,
} from "./lcdapi";
export { RestClient } from "./restclient";

6
packages/sdk38/types/lcdapi/auth.d.ts vendored
View File

@ -1,5 +1,5 @@
import { Coin } from "../coins";
import { LcdClient, LcdModule } from "./lcdclient";
import { LcdClient, LcdExtension } from "./lcdclient";
export interface CosmosSdkAccount {
/** Bech32 account address */
readonly address: string;
@ -16,9 +16,9 @@ export interface AuthAccountsResponse {
readonly value: CosmosSdkAccount;
};
}
export interface AuthModule extends LcdModule {
export interface AuthExtension extends LcdExtension {
readonly auth: {
readonly account: (address: string) => Promise<AuthAccountsResponse>;
};
}
export declare function setupAuthModule(base: LcdClient): AuthModule;
export declare function setupAuthExtension(base: LcdClient): AuthExtension;

6
packages/sdk38/types/lcdapi/index.d.ts vendored
View File

@ -1,5 +1,5 @@
export { AuthModule, AuthAccountsResponse, setupAuthModule } from "./auth";
export { setupSupplyModule, SupplyModule, TotalSupplyAllReponse, TotalSupplyReponse } from "./supply";
export { AuthExtension, AuthAccountsResponse, setupAuthExtension } from "./auth";
export { setupSupplyExtension, SupplyExtension, TotalSupplyAllReponse, TotalSupplyReponse } from "./supply";
export {
BlockResponse,
BroadcastMode,
@ -9,4 +9,4 @@ export {
SearchTxsResponse,
TxsResponse,
} from "./base";
export { LcdApiArray, LcdClient, LcdModule, normalizeLcdApiArray } from "./lcdclient";
export { LcdApiArray, LcdClient, LcdExtension, normalizeLcdApiArray } from "./lcdclient";

151
packages/sdk38/types/lcdapi/lcdclient.d.ts vendored
View File

@ -11,8 +11,8 @@ import {
/** Unfortunately, Cosmos SDK encodes empty arrays as null */
export declare type LcdApiArray<T> = readonly T[] | null;
export declare function normalizeLcdApiArray<T>(backend: LcdApiArray<T>): readonly T[];
export declare type LcdModule = Record<string, Record<string, (...args: any[]) => any>>;
declare type LcdModuleSetup<M extends LcdModule> = (base: LcdClient) => M;
export declare type LcdExtension = Record<string, Record<string, (...args: any[]) => any>>;
declare type LcdExtensionSetup<P extends LcdExtension> = (base: LcdClient) => P;
export interface LcdClientBaseOptions {
readonly apiUrl: string;
readonly broadcastMode?: BroadcastMode;
@ -31,104 +31,109 @@ export interface LcdClientBaseOptions {
*/
export declare class LcdClient {
/** Constructs an LCD client with 0 modules */
static withModules(options: LcdClientBaseOptions): LcdClient;
static withExtensions(options: LcdClientBaseOptions): LcdClient;
/** Constructs an LCD client with 1 module */
static withModules<A extends LcdModule>(
static withExtensions<A extends LcdExtension>(
options: LcdClientBaseOptions,
setupModuleA: LcdModuleSetup<A>,
setupModuleA: LcdExtensionSetup<A>,
): LcdClient & A;
/** Constructs an LCD client with 2 modules */
static withModules<A extends LcdModule, B extends LcdModule>(
static withExtensions<A extends LcdExtension, B extends LcdExtension>(
options: LcdClientBaseOptions,
setupModuleA: LcdModuleSetup<A>,
setupModuleB: LcdModuleSetup<B>,
setupModuleA: LcdExtensionSetup<A>,
setupModuleB: LcdExtensionSetup<B>,
): LcdClient & A & B;
/** Constructs an LCD client with 3 modules */
static withModules<A extends LcdModule, B extends LcdModule, C extends LcdModule>(
static withExtensions<A extends LcdExtension, B extends LcdExtension, C extends LcdExtension>(
options: LcdClientBaseOptions,
setupModuleA: LcdModuleSetup<A>,
setupModuleB: LcdModuleSetup<B>,
setupModuleC: LcdModuleSetup<C>,
setupModuleA: LcdExtensionSetup<A>,
setupModuleB: LcdExtensionSetup<B>,
setupModuleC: LcdExtensionSetup<C>,
): LcdClient & A & B & C;
/** Constructs an LCD client with 4 modules */
static withModules<A extends LcdModule, B extends LcdModule, C extends LcdModule, D extends LcdModule>(
static withExtensions<
A extends LcdExtension,
B extends LcdExtension,
C extends LcdExtension,
D extends LcdExtension
>(
options: LcdClientBaseOptions,
setupModuleA: LcdModuleSetup<A>,
setupModuleB: LcdModuleSetup<B>,
setupModuleC: LcdModuleSetup<C>,
setupModuleD: LcdModuleSetup<D>,
setupModuleA: LcdExtensionSetup<A>,
setupModuleB: LcdExtensionSetup<B>,
setupModuleC: LcdExtensionSetup<C>,
setupModuleD: LcdExtensionSetup<D>,
): LcdClient & A & B & C & D;
/** Constructs an LCD client with 5 modules */
static withModules<
A extends LcdModule,
B extends LcdModule,
C extends LcdModule,
D extends LcdModule,
E extends LcdModule
static withExtensions<
A extends LcdExtension,
B extends LcdExtension,
C extends LcdExtension,
D extends LcdExtension,
E extends LcdExtension
>(
options: LcdClientBaseOptions,
setupModuleA: LcdModuleSetup<A>,
setupModuleB: LcdModuleSetup<B>,
setupModuleC: LcdModuleSetup<C>,
setupModuleD: LcdModuleSetup<D>,
setupModuleE: LcdModuleSetup<E>,
setupModuleA: LcdExtensionSetup<A>,
setupModuleB: LcdExtensionSetup<B>,
setupModuleC: LcdExtensionSetup<C>,
setupModuleD: LcdExtensionSetup<D>,
setupModuleE: LcdExtensionSetup<E>,
): LcdClient & A & B & C & D & E;
/** Constructs an LCD client with 6 modules */
static withModules<
A extends LcdModule,
B extends LcdModule,
C extends LcdModule,
D extends LcdModule,
E extends LcdModule,
F extends LcdModule
static withExtensions<
A extends LcdExtension,
B extends LcdExtension,
C extends LcdExtension,
D extends LcdExtension,
E extends LcdExtension,
F extends LcdExtension
>(
options: LcdClientBaseOptions,
setupModuleA: LcdModuleSetup<A>,
setupModuleB: LcdModuleSetup<B>,
setupModuleC: LcdModuleSetup<C>,
setupModuleD: LcdModuleSetup<D>,
setupModuleE: LcdModuleSetup<E>,
setupModuleF: LcdModuleSetup<F>,
setupModuleA: LcdExtensionSetup<A>,
setupModuleB: LcdExtensionSetup<B>,
setupModuleC: LcdExtensionSetup<C>,
setupModuleD: LcdExtensionSetup<D>,
setupModuleE: LcdExtensionSetup<E>,
setupModuleF: LcdExtensionSetup<F>,
): LcdClient & A & B & C & D & E & F;
/** Constructs an LCD client with 7 modules */
static withModules<
A extends LcdModule,
B extends LcdModule,
C extends LcdModule,
D extends LcdModule,
E extends LcdModule,
F extends LcdModule,
G extends LcdModule
static withExtensions<
A extends LcdExtension,
B extends LcdExtension,
C extends LcdExtension,
D extends LcdExtension,
E extends LcdExtension,
F extends LcdExtension,
G extends LcdExtension
>(
options: LcdClientBaseOptions,
setupModuleA: LcdModuleSetup<A>,
setupModuleB: LcdModuleSetup<B>,
setupModuleC: LcdModuleSetup<C>,
setupModuleD: LcdModuleSetup<D>,
setupModuleE: LcdModuleSetup<E>,
setupModuleF: LcdModuleSetup<F>,
setupModuleG: LcdModuleSetup<G>,
setupModuleA: LcdExtensionSetup<A>,
setupModuleB: LcdExtensionSetup<B>,
setupModuleC: LcdExtensionSetup<C>,
setupModuleD: LcdExtensionSetup<D>,
setupModuleE: LcdExtensionSetup<E>,
setupModuleF: LcdExtensionSetup<F>,
setupModuleG: LcdExtensionSetup<G>,
): LcdClient & A & B & C & D & E & F & G;
/** Constructs an LCD client with 8 modules */
static withModules<
A extends LcdModule,
B extends LcdModule,
C extends LcdModule,
D extends LcdModule,
E extends LcdModule,
F extends LcdModule,
G extends LcdModule,
H extends LcdModule
static withExtensions<
A extends LcdExtension,
B extends LcdExtension,
C extends LcdExtension,
D extends LcdExtension,
E extends LcdExtension,
F extends LcdExtension,
G extends LcdExtension,
H extends LcdExtension
>(
options: LcdClientBaseOptions,
setupModuleA: LcdModuleSetup<A>,
setupModuleB: LcdModuleSetup<B>,
setupModuleC: LcdModuleSetup<C>,
setupModuleD: LcdModuleSetup<D>,
setupModuleE: LcdModuleSetup<E>,
setupModuleF: LcdModuleSetup<F>,
setupModuleG: LcdModuleSetup<G>,
setupModuleH: LcdModuleSetup<H>,
setupModuleA: LcdExtensionSetup<A>,
setupModuleB: LcdExtensionSetup<B>,
setupModuleC: LcdExtensionSetup<C>,
setupModuleD: LcdExtensionSetup<D>,
setupModuleE: LcdExtensionSetup<E>,
setupModuleF: LcdExtensionSetup<F>,
setupModuleG: LcdExtensionSetup<G>,
setupModuleH: LcdExtensionSetup<H>,
): LcdClient & A & B & C & D & E & F & G & H;
private readonly client;
private readonly broadcastMode;

6
packages/sdk38/types/lcdapi/supply.d.ts vendored
View File

@ -1,5 +1,5 @@
import { Coin } from "../coins";
import { LcdApiArray, LcdClient, LcdModule } from "./lcdclient";
import { LcdApiArray, LcdClient, LcdExtension } from "./lcdclient";
export interface TotalSupplyAllReponse {
readonly height: string;
readonly result: LcdApiArray<Coin>;
@ -9,10 +9,10 @@ export interface TotalSupplyReponse {
/** The amount */
readonly result: string;
}
export interface SupplyModule extends LcdModule {
export interface SupplyExtension extends LcdExtension {
readonly supply: {
readonly totalAll: () => Promise<TotalSupplyAllReponse>;
readonly total: (denom: string) => Promise<TotalSupplyReponse>;
};
}
export declare function setupSupplyModule(base: LcdClient): SupplyModule;
export declare function setupSupplyExtension(base: LcdClient): SupplyExtension;