schemos 0.1.1 → 0.2.0

package/dist/msg.js

@@ -0,0 +1,98 @@
+import { Ajv } from 'ajv';
+import { cosmwasmFormats } from './formats.js';
+// ---------------------------------------------------------------------------
+// Level 2: buildMsg — validated envelope builder
+// ---------------------------------------------------------------------------
+/** Module-level Ajv validator cache. WeakMap allows GC of out-of-scope schemas. */
+const validatorCache = new WeakMap();
+function getValidator(schema) {
+    const key = schema;
+    let cached = validatorCache.get(key);
+    if (!cached) {
+        const ajv = new Ajv();
+        for (const [name, def] of Object.entries(cosmwasmFormats)) {
+            ajv.addFormat(name, def);
+        }
+        const validate = ajv.compile(schema);
+        cached = { validate, ajv };
+        validatorCache.set(key, cached);
+    }
+    return cached;
+}
+/**
+ * Create a typed message builder from a JSON Schema.
+ *
+ * Returns a callable that builds validated `{ [msgName]: args }` envelopes.
+ * The schema is compiled once and cached — safe for batch usage.
+ *
+ * This follows the same pattern as `createTypedContract`: the schema type
+ * is resolved once at factory level, avoiding expensive repeated evaluation
+ * of `FromSchema` on complex schemas (12+ oneOf branches with $ref).
+ *
+ * @example
+ * ```ts
+ * import { createMsgBuilder } from 'schemos/msg'
+ * import { cw20 } from 'schemos/schemas'
+ *
+ * const cw20Msg = createMsgBuilder(cw20.execute)
+ * const msg = cw20Msg('transfer', { amount: '1000', recipient: 'osmo1...' })
+ * // msg is typed as { transfer: { amount: string; recipient: string } }
+ *
+ * // Batch usage — schema compiled once, reused across calls:
+ * const msgs = [
+ *   cw20Msg('transfer', { amount: '100', recipient: addr1 }),
+ *   cw20Msg('transfer', { amount: '200', recipient: addr2 }),
+ * ]
+ * ```
+ */
+export function createMsgBuilder(schema) {
+    return ((msg, args, options) => {
+        return buildMsg(schema, msg, args, options);
+    });
+}
+// TS2589 mitigation: factory isolates FromSchema to creation time, but MsgValidator
+// exposes it directly as return type — tsc fully resolves it on declaration emit.
+// Overload hides the impl behind `unknown`. MsgBuilder doesn't need this because
+// its inner generic K (MessageNames/MessageArgs) defers resolution.
+export function createMsgValidator(schema) {
+    return (data, options) => {
+        return validateMsg(schema, data, options);
+    };
+}
+/**
+ * Validate data against a JSON Schema. Returns the data as-is if valid,
+ * throws a descriptive error if invalid.
+ *
+ * Reuses the same WeakMap-based validator cache as `buildMsg` — safe for
+ * repeated calls with the same schema reference.
+ *
+ * @example
+ * ```ts
+ * import { validateMsg } from 'schemos'
+ *
+ * const initMsg = validateMsg(cw20InstantiateSchema, {
+ *   name: 'Token', symbol: 'TKN', decimals: 6, initial_balances: []
+ * })
+ * ```
+ */
+export function validateMsg(schema, data, options) {
+    const { validate, ajv } = getValidator(schema);
+    if (!validate(data)) {
+        const prefix = options?.context ?? 'Validation failed';
+        throw new Error(`${prefix}: ${ajv.errorsText(validate.errors)}`);
+    }
+    return data;
+}
+/**
+ * Build a validated message envelope. Used internally by createMsgBuilder
+ * and createTypedContract. Accepts loose types — prefer createMsgBuilder
+ * for type-safe usage.
+ */
+export function buildMsg(schema, msg, args, options) {
+    const envelope = { [msg]: args };
+    const context = options?.context
+        ? `${options.context} validation failed for "${msg}"`
+        : `Validation failed for "${msg}"`;
+    return validateMsg(schema, envelope, { context });
+}
+//# sourceMappingURL=msg.js.map

package/dist/msg.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"msg.js","sourceRoot":"","sources":["../src/msg.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAyB,MAAM,KAAK,CAAA;AAEhD,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAuB9C,8EAA8E;AAC9E,iDAAiD;AACjD,8EAA8E;AAE9E,mFAAmF;AACnF,MAAM,cAAc,GAAG,IAAI,OAAO,EAG/B,CAAA;AAEH,SAAS,YAAY,CAAC,MAAkB;IAItC,MAAM,GAAG,GAAG,MAAgB,CAAA;IAC5B,IAAI,MAAM,GAAG,cAAc,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;IACpC,IAAI,CAAC,MAAM,EAAE,CAAC;QACZ,MAAM,GAAG,GAAG,IAAI,GAAG,EAAE,CAAA;QACrB,KAAK,MAAM,CAAC,IAAI,EAAE,GAAG,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,eAAe,CAAC,EAAE,CAAC;YAC1D,GAAG,CAAC,SAAS,CAAC,IAAI,EAAE,GAAG,CAAC,CAAA;QAC1B,CAAC;QACD,MAAM,QAAQ,GAAG,GAAG,CAAC,OAAO,CAAC,MAAiC,CAAC,CAAA;QAC/D,MAAM,GAAG,EAAE,QAAQ,EAAE,GAAG,EAAE,CAAA;QAC1B,cAAc,CAAC,GAAG,CAAC,GAAG,EAAE,MAAM,CAAC,CAAA;IACjC,CAAC;IACD,OAAO,MAAM,CAAA;AACf,CAAC;AASD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,UAAU,gBAAgB,CAC9B,MAAe;IAEf,OAAO,CAAC,CAAC,GAAW,EAAE,IAAa,EAAE,OAA8B,EAAE,EAAE;QACrE,OAAO,QAAQ,CAAC,MAAM,EAAE,GAAG,EAAE,IAAI,EAAE,OAAO,CAAC,CAAA;IAC7C,CAAC,CAAoC,CAAA;AACvC,CAAC;AAgCD,oFAAoF;AACpF,kFAAkF;AAClF,iFAAiF;AACjF,oEAAoE;AACpE,MAAM,UAAU,kBAAkB,CAAC,MAAkB;IACnD,OAAO,CAAC,IAAa,EAAE,OAA8B,EAAE,EAAE;QACvD,OAAO,WAAW,CAAC,MAAM,EAAE,IAAI,EAAE,OAAO,CAAC,CAAA;IAC3C,CAAC,CAAA;AACH,CAAC;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,WAAW,CACzB,MAAkB,EAClB,IAAa,EACb,OAA8B;IAE9B,MAAM,EAAE,QAAQ,EAAE,GAAG,EAAE,GAAG,YAAY,CAAC,MAAM,CAAC,CAAA;IAC9C,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;QACpB,MAAM,MAAM,GAAG,OAAO,EAAE,OAAO,IAAI,mBAAmB,CAAA;QACtD,MAAM,IAAI,KAAK,CAAC,GAAG,MAAM,KAAK,GAAG,CAAC,UAAU,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,CAAA;IAClE,CAAC;IACD,OAAO,IAAS,CAAA;AAClB,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,QAAQ,CACtB,MAAkB,EAClB,GAAW,EACX,IAAa,EACb,OAA8B;IAE9B,MAAM,QAAQ,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,IAAI,EAAE,CAAA;IAChC,MAAM,OAAO,GAAG,OAAO,EAAE,OAAO;QAC9B,CAAC,CAAC,GAAG,OAAO,CAAC,OAAO,2BAA2B,GAAG,GAAG;QACrD,CAAC,CAAC,0BAA0B,GAAG,GAAG,CAAA;IACpC,OAAO,WAAW,CAAC,MAAM,EAAE,QAAQ,EAAE,EAAE,OAAO,EAAE,CAAC,CAAA;AACnD,CAAC"}

package/dist/msg.test-d.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=msg.test-d.d.ts.map

package/dist/msg.test-d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"msg.test-d.d.ts","sourceRoot":"","sources":["../src/msg.test-d.ts"],"names":[],"mappings":""}

package/dist/msg.test-d.js

@@ -0,0 +1,121 @@
+import { assertType, expectTypeOf, test } from 'vitest';
+import { createMsgBuilder, createMsgValidator } from './msg.js';
+import { cw20ExecuteSchema, cw20InstantiateSchema, cw20QuerySchema, } from './schemas/cw20/index.js';
+test('InferMsg produces same type as FromSchema', () => {
+    expectTypeOf().toEqualTypeOf();
+    expectTypeOf().toEqualTypeOf();
+});
+test('InferMsg<execute> accepts valid messages', () => {
+    assertType({
+        transfer: { amount: '1000', recipient: 'osmo1abc' },
+    });
+    assertType({ burn: { amount: '500' } });
+    assertType({
+        send: { amount: '100', contract: 'osmo1xyz', msg: 'base64' },
+    });
+});
+test('InferMsg<query> accepts valid messages', () => {
+    assertType({ balance: { address: 'osmo1abc' } });
+    assertType({ token_info: {} });
+});
+test('MessageNames extracts execute message names', () => {
+    assertType('transfer');
+    assertType('burn');
+    assertType('send');
+    assertType('mint');
+    assertType('increase_allowance');
+    assertType('decrease_allowance');
+    assertType('transfer_from');
+    assertType('send_from');
+    assertType('burn_from');
+});
+test('MessageNames extracts query message names', () => {
+    assertType('balance');
+    assertType('token_info');
+    assertType('allowance');
+    assertType('all_allowances');
+    assertType('all_accounts');
+});
+test('MessageNames rejects invalid names', () => {
+    // @ts-expect-error - 'xfer' is not a valid execute message name
+    assertType('xfer');
+    // @ts-expect-error - 'balances' is not a valid query name
+    assertType('balances');
+});
+// ---------------------------------------------------------------------------
+// MessageArgs: narrow args for a specific message name
+// ---------------------------------------------------------------------------
+test('MessageArgs narrows transfer to { amount, recipient }', () => {
+    expectTypeOf().toEqualTypeOf();
+});
+test('MessageArgs narrows burn to { amount }', () => {
+    expectTypeOf().toEqualTypeOf();
+});
+test('MessageArgs narrows balance query to { address }', () => {
+    expectTypeOf().toEqualTypeOf();
+});
+test('MessageArgs narrows token_info query to {}', () => {
+    expectTypeOf().toEqualTypeOf();
+});
+// ---------------------------------------------------------------------------
+// InferResponse: extract typed response from responses schema map
+// ---------------------------------------------------------------------------
+test('InferResponse infers balance response', () => {
+    expectTypeOf().toEqualTypeOf();
+});
+test('InferResponse infers token_info response', () => {
+    expectTypeOf().toHaveProperty('name');
+    expectTypeOf().toHaveProperty('symbol');
+    expectTypeOf().toHaveProperty('decimals');
+    expectTypeOf().toHaveProperty('total_supply');
+});
+test('InferResponse rejects invalid response key', () => {
+});
+// ---------------------------------------------------------------------------
+// createMsgBuilder: return type narrowing (Level 2 type tests)
+// ---------------------------------------------------------------------------
+const cw20Msg = createMsgBuilder(cw20ExecuteSchema);
+const cw20QueryMsg = createMsgBuilder(cw20QuerySchema);
+test('createMsgBuilder return type narrows to single-key envelope', () => {
+    const result = cw20Msg('transfer', {
+        amount: '1000',
+        recipient: 'osmo1abc',
+    });
+    expectTypeOf(result).toEqualTypeOf();
+});
+test('createMsgBuilder return type is NOT the full union', () => {
+    const result = cw20Msg('transfer', {
+        amount: '1000',
+        recipient: 'osmo1abc',
+    });
+    expectTypeOf(result).not.toEqualTypeOf();
+});
+test('createMsgBuilder narrows query envelope too', () => {
+    const result = cw20QueryMsg('balance', { address: 'osmo1abc' });
+    expectTypeOf(result).toEqualTypeOf();
+});
+test('createMsgBuilder rejects invalid message name at type level', () => {
+    expectTypeOf(cw20Msg).parameter(0).not.toExtend();
+});
+test('createMsgBuilder rejects wrong args shape at type level', () => {
+    // Missing 'recipient' — should not be assignable to transfer args
+    expectTypeOf().not.toExtend();
+});
+test('createMsgBuilder rejects typo in field name at type level', () => {
+    // 'recipent' is a typo — should not be assignable
+    expectTypeOf().not.toExtend();
+});
+// ---------------------------------------------------------------------------
+// createMsgValidator: factory-level type inference
+// ---------------------------------------------------------------------------
+test('createMsgValidator infers instantiate struct properties', () => {
+    const validateInit = createMsgValidator(cw20InstantiateSchema);
+    expectTypeOf().toHaveProperty('name');
+    expectTypeOf().toHaveProperty('symbol');
+    expectTypeOf().toHaveProperty('decimals');
+});
+test('createMsgValidator infers execute msg union', () => {
+    const validateExec = createMsgValidator(cw20ExecuteSchema);
+    expectTypeOf().toEqualTypeOf();
+});
+//# sourceMappingURL=msg.test-d.js.map

package/dist/msg.test-d.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"msg.test-d.js","sourceRoot":"","sources":["../src/msg.test-d.ts"],"names":[],"mappings":"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"}

package/dist/msg.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=msg.test.d.ts.map

package/dist/msg.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"msg.test.d.ts","sourceRoot":"","sources":["../src/msg.test.ts"],"names":[],"mappings":""}

package/dist/msg.test.js

@@ -0,0 +1,177 @@
+import { Ajv } from 'ajv';
+import { describe, expect, test, vi } from 'vitest';
+import { buildMsg, createMsgBuilder, createMsgValidator, validateMsg, } from './msg.js';
+import { cw20ExecuteSchema, cw20InstantiateSchema, cw20QuerySchema, } from './schemas/cw20/index.js';
+describe('createMsgBuilder', () => {
+    const cw20Msg = createMsgBuilder(cw20ExecuteSchema);
+    const cw20QueryMsg = createMsgBuilder(cw20QuerySchema);
+    test('returns correct envelope for valid execute message', () => {
+        const result = cw20Msg('transfer', {
+            amount: '1000',
+            recipient: 'osmo1abc',
+        });
+        expect(result).toEqual({
+            transfer: { amount: '1000', recipient: 'osmo1abc' },
+        });
+    });
+    test('returns correct envelope for burn', () => {
+        const result = cw20Msg('burn', { amount: '500' });
+        expect(result).toEqual({ burn: { amount: '500' } });
+    });
+    test('works with query schema', () => {
+        const result = cw20QueryMsg('balance', { address: 'osmo1abc' });
+        expect(result).toEqual({ balance: { address: 'osmo1abc' } });
+    });
+    test('works with query schema (empty args)', () => {
+        const result = cw20QueryMsg('token_info', {});
+        expect(result).toEqual({ token_info: {} });
+    });
+    test('throws on missing required field', () => {
+        expect(() => cw20Msg('transfer', 
+        // @ts-expect-error - testing runtime: missing recipient
+        { amount: '1000' })).toThrow('Validation failed for "transfer"');
+    });
+    test('throws on wrong type (number instead of string for Uint128)', () => {
+        expect(() => cw20Msg('transfer', 
+        // @ts-expect-error - testing runtime: amount should be string
+        { amount: 1000, recipient: 'osmo1abc' })).toThrow('Validation failed for "transfer"');
+    });
+    test('throws on additional properties', () => {
+        expect(() => cw20Msg('burn', 
+        // @ts-expect-error - testing runtime: extra field
+        { amount: '500', extraField: true })).toThrow('Validation failed for "burn"');
+    });
+    test('context option prefixes error message', () => {
+        const cw20Execute = createMsgBuilder(cw20ExecuteSchema);
+        expect(() => cw20Execute('transfer', 
+        // @ts-expect-error - testing runtime: missing recipient
+        { amount: '1000' }, { context: 'Execute' })).toThrow('Execute validation failed for "transfer"');
+    });
+    test('context option for query', () => {
+        const cw20Query = createMsgBuilder(cw20QuerySchema);
+        expect(() => cw20Query('balance', 
+        // @ts-expect-error - testing runtime: missing address
+        {}, { context: 'Query' })).toThrow('Query validation failed for "balance"');
+    });
+});
+describe('validateMsg', () => {
+    // A simple flat struct schema — typical for instantiate messages
+    const instantiateSchema = {
+        type: 'object',
+        required: ['name', 'symbol', 'decimals', 'initial_balances'],
+        additionalProperties: false,
+        properties: {
+            name: { type: 'string' },
+            symbol: { type: 'string' },
+            decimals: { type: 'integer' },
+            initial_balances: { type: 'array', items: { type: 'object' } },
+        },
+    };
+    test('returns data as-is when valid', () => {
+        const data = {
+            name: 'Token',
+            symbol: 'TKN',
+            decimals: 6,
+            initial_balances: [],
+        };
+        const result = validateMsg(instantiateSchema, data);
+        expect(result).toBe(data);
+    });
+    test('throws when required field is missing', () => {
+        expect(() => validateMsg(instantiateSchema, { name: 'Token', symbol: 'TKN' })).toThrow('Validation failed:');
+    });
+    test('throws when field has wrong type', () => {
+        expect(() => validateMsg(instantiateSchema, {
+            name: 'Token',
+            symbol: 'TKN',
+            decimals: 'six',
+            initial_balances: [],
+        })).toThrow('Validation failed:');
+    });
+    test('context option prefixes error message', () => {
+        expect(() => validateMsg(instantiateSchema, { name: 'Token' }, { context: 'Instantiate' })).toThrow('Instantiate:');
+    });
+    test('works for flat struct schema (instantiate use case)', () => {
+        const result = validateMsg(instantiateSchema, {
+            name: 'Token',
+            symbol: 'TKN',
+            decimals: 6,
+            initial_balances: [],
+        });
+        expect(result.name).toBe('Token');
+        expect(result.decimals).toBe(6);
+    });
+    test('reuses validator cache for same schema reference', () => {
+        const compileSpy = vi.spyOn(Ajv.prototype, 'compile');
+        validateMsg(instantiateSchema, {
+            name: 'A',
+            symbol: 'A',
+            decimals: 0,
+            initial_balances: [],
+        });
+        const firstCallCount = compileSpy.mock.calls.length;
+        validateMsg(instantiateSchema, {
+            name: 'B',
+            symbol: 'B',
+            decimals: 0,
+            initial_balances: [],
+        });
+        expect(compileSpy.mock.calls.length).toBe(firstCallCount);
+        compileSpy.mockRestore();
+    });
+});
+describe('buildMsg Ajv caching', () => {
+    test('reuses compiled validator for same schema reference', () => {
+        const compileSpy = vi.spyOn(Ajv.prototype, 'compile');
+        // First call compiles the schema
+        buildMsg(cw20ExecuteSchema, 'transfer', {
+            amount: '1',
+            recipient: 'osmo1abc',
+        });
+        const firstCallCount = compileSpy.mock.calls.length;
+        // Second call should reuse cached validator
+        buildMsg(cw20ExecuteSchema, 'burn', { amount: '1' });
+        expect(compileSpy.mock.calls.length).toBe(firstCallCount);
+        compileSpy.mockRestore();
+    });
+});
+describe('createMsgValidator', () => {
+    const validateInit = createMsgValidator(cw20InstantiateSchema);
+    test('returns data as-is when valid', () => {
+        const result = validateInit({
+            name: 'Token',
+            symbol: 'TKN',
+            decimals: 6,
+            initial_balances: [],
+        });
+        expect(result.name).toBe('Token');
+        expect(result.decimals).toBe(6);
+    });
+    test('throws when required field is missing', () => {
+        // @ts-expect-error — intentionally missing required fields for runtime test
+        expect(() => validateInit({ name: 'Token', symbol: 'TKN' })).toThrow('Validation failed:');
+    });
+    test('throws when field has wrong type', () => {
+        expect(() => validateInit({
+            name: 'Token',
+            symbol: 'TKN',
+            // @ts-expect-error — intentionally wrong type for runtime test
+            decimals: 'six',
+            initial_balances: [],
+        })).toThrow('Validation failed:');
+    });
+    test('context option prefixes error message', () => {
+        expect(() => 
+        // @ts-expect-error — intentionally missing required fields for runtime test
+        validateInit({ name: 'Token' }, { context: 'Instantiate' })).toThrow('Instantiate:');
+    });
+    test('reuses validator cache across calls', () => {
+        const compileSpy = vi.spyOn(Ajv.prototype, 'compile');
+        validateInit({ name: 'A', symbol: 'A', decimals: 0, initial_balances: [] });
+        const firstCallCount = compileSpy.mock.calls.length;
+        validateInit({ name: 'B', symbol: 'B', decimals: 0, initial_balances: [] });
+        expect(compileSpy.mock.calls.length).toBe(firstCallCount);
+        compileSpy.mockRestore();
+    });
+});
+//# sourceMappingURL=msg.test.js.map

package/dist/msg.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"msg.test.js","sourceRoot":"","sources":["../src/msg.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,KAAK,CAAA;AACzB,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,EAAE,EAAE,MAAM,QAAQ,CAAA;AACnD,OAAO,EACL,QAAQ,EACR,gBAAgB,EAChB,kBAAkB,EAClB,WAAW,GACZ,MAAM,UAAU,CAAA;AACjB,OAAO,EACL,iBAAiB,EACjB,qBAAqB,EACrB,eAAe,GAChB,MAAM,yBAAyB,CAAA;AAEhC,QAAQ,CAAC,kBAAkB,EAAE,GAAG,EAAE;IAChC,MAAM,OAAO,GAAG,gBAAgB,CAAC,iBAAiB,CAAC,CAAA;IACnD,MAAM,YAAY,GAAG,gBAAgB,CAAC,eAAe,CAAC,CAAA;IAEtD,IAAI,CAAC,oDAAoD,EAAE,GAAG,EAAE;QAC9D,MAAM,MAAM,GAAG,OAAO,CAAC,UAAU,EAAE;YACjC,MAAM,EAAE,MAAM;YACd,SAAS,EAAE,UAAU;SACtB,CAAC,CAAA;QACF,MAAM,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC;YACrB,QAAQ,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE;SACpD,CAAC,CAAA;IACJ,CAAC,CAAC,CAAA;IAEF,IAAI,CAAC,mCAAmC,EAAE,GAAG,EAAE;QAC7C,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,CAAA;QACjD,MAAM,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,EAAE,IAAI,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC,CAAA;IACrD,CAAC,CAAC,CAAA;IAEF,IAAI,CAAC,yBAAyB,EAAE,GAAG,EAAE;QACnC,MAAM,MAAM,GAAG,YAAY,CAAC,SAAS,EAAE,EAAE,OAAO,EAAE,UAAU,EAAE,CAAC,CAAA;QAC/D,MAAM,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,EAAE,OAAO,EAAE,EAAE,OAAO,EAAE,UAAU,EAAE,EAAE,CAAC,CAAA;IAC9D,CAAC,CAAC,CAAA;IAEF,IAAI,CAAC,sCAAsC,EAAE,GAAG,EAAE;QAChD,MAAM,MAAM,GAAG,YAAY,CAAC,YAAY,EAAE,EAAE,CAAC,CAAA;QAC7C,MAAM,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,EAAE,UAAU,EAAE,EAAE,EAAE,CAAC,CAAA;IAC5C,CAAC,CAAC,CAAA;IAEF,IAAI,CAAC,kCAAkC,EAAE,GAAG,EAAE;QAC5C,MAAM,CAAC,GAAG,EAAE,CACV,OAAO,CACL,UAAU;QACV,wDAAwD;QACxD,EAAE,MAAM,EAAE,MAAM,EAAE,CACnB,CACF,CAAC,OAAO,CAAC,kCAAkC,CAAC,CAAA;IAC/C,CAAC,CAAC,CAAA;IAEF,IAAI,CAAC,6DAA6D,EAAE,GAAG,EAAE;QACvE,MAAM,CAAC,GAAG,EAAE,CACV,OAAO,CACL,UAAU;QACV,8DAA8D;QAC9D,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,EAAE,UAAU,EAAE,CACxC,CACF,CAAC,OAAO,CAAC,kCAAkC,CAAC,CAAA;IAC/C,CAAC,CAAC,CAAA;IAEF,IAAI,CAAC,iCAAiC,EAAE,GAAG,EAAE;QAC3C,MAAM,CAAC,GAAG,EAAE,CACV,OAAO,CACL,MAAM;QACN,kDAAkD;QAClD,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,CACpC,CACF,CAAC,OAAO,CAAC,8BAA8B,CAAC,CAAA;IAC3C,CAAC,CAAC,CAAA;IAEF,IAAI,CAAC,uCAAuC,EAAE,GAAG,EAAE;QACjD,MAAM,WAAW,GAAG,gBAAgB,CAAC,iBAAiB,CAAC,CAAA;QACvD,MAAM,CAAC,GAAG,EAAE,CACV,WAAW,CACT,UAAU;QACV,wDAAwD;QACxD,EAAE,MAAM,EAAE,MAAM,EAAE,EAClB,EAAE,OAAO,EAAE,SAAS,EAAE,CACvB,CACF,CAAC,OAAO,CAAC,0CAA0C,CAAC,CAAA;IACvD,CAAC,CAAC,CAAA;IAEF,IAAI,CAAC,0BAA0B,EAAE,GAAG,EAAE;QACpC,MAAM,SAAS,GAAG,gBAAgB,CAAC,eAAe,CAAC,CAAA;QACnD,MAAM,CAAC,GAAG,EAAE,CACV,SAAS,CACP,SAAS;QACT,sDAAsD;QACtD,EAAE,EACF,EAAE,OAAO,EAAE,OAAO,EAAE,CACrB,CACF,CAAC,OAAO,CAAC,uCAAuC,CAAC,CAAA;IACpD,CAAC,CAAC,CAAA;AACJ,CAAC,CAAC,CAAA;AAEF,QAAQ,CAAC,aAAa,EAAE,GAAG,EAAE;IAC3B,iEAAiE;IACjE,MAAM,iBAAiB,GAAG;QACxB,IAAI,EAAE,QAAQ;QACd,QAAQ,EAAE,CAAC,MAAM,EAAE,QAAQ,EAAE,UAAU,EAAE,kBAAkB,CAAC;QAC5D,oBAAoB,EAAE,KAAK;QAC3B,UAAU,EAAE;YACV,IAAI,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;YACxB,MAAM,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE;YAC1B,QAAQ,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE;YAC7B,gBAAgB,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE;SAC/D;KACO,CAAA;IAEV,IAAI,CAAC,+BAA+B,EAAE,GAAG,EAAE;QACzC,MAAM,IAAI,GAAG;YACX,IAAI,EAAE,OAAO;YACb,MAAM,EAAE,KAAK;YACb,QAAQ,EAAE,CAAC;YACX,gBAAgB,EAAE,EAAE;SACrB,CAAA;QACD,MAAM,MAAM,GAAG,WAAW,CAAC,iBAAiB,EAAE,IAAI,CAAC,CAAA;QACnD,MAAM,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;IAC3B,CAAC,CAAC,CAAA;IAEF,IAAI,CAAC,uCAAuC,EAAE,GAAG,EAAE;QACjD,MAAM,CAAC,GAAG,EAAE,CACV,WAAW,CAAC,iBAAiB,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,CACjE,CAAC,OAAO,CAAC,oBAAoB,CAAC,CAAA;IACjC,CAAC,CAAC,CAAA;IAEF,IAAI,CAAC,kCAAkC,EAAE,GAAG,EAAE;QAC5C,MAAM,CAAC,GAAG,EAAE,CACV,WAAW,CAAC,iBAAiB,EAAE;YAC7B,IAAI,EAAE,OAAO;YACb,MAAM,EAAE,KAAK;YACb,QAAQ,EAAE,KAAK;YACf,gBAAgB,EAAE,EAAE;SACrB,CAAC,CACH,CAAC,OAAO,CAAC,oBAAoB,CAAC,CAAA;IACjC,CAAC,CAAC,CAAA;IAEF,IAAI,CAAC,uCAAuC,EAAE,GAAG,EAAE;QACjD,MAAM,CAAC,GAAG,EAAE,CACV,WAAW,CACT,iBAAiB,EACjB,EAAE,IAAI,EAAE,OAAO,EAAE,EACjB,EAAE,OAAO,EAAE,aAAa,EAAE,CAC3B,CACF,CAAC,OAAO,CAAC,cAAc,CAAC,CAAA;IAC3B,CAAC,CAAC,CAAA;IAEF,IAAI,CAAC,qDAAqD,EAAE,GAAG,EAAE;QAC/D,MAAM,MAAM,GAAG,WAAW,CAKvB,iBAAiB,EAAE;YACpB,IAAI,EAAE,OAAO;YACb,MAAM,EAAE,KAAK;YACb,QAAQ,EAAE,CAAC;YACX,gBAAgB,EAAE,EAAE;SACrB,CAAC,CAAA;QACF,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;QACjC,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAA;IACjC,CAAC,CAAC,CAAA;IAEF,IAAI,CAAC,kDAAkD,EAAE,GAAG,EAAE;QAC5D,MAAM,UAAU,GAAG,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,SAAS,EAAE,SAAS,CAAC,CAAA;QAErD,WAAW,CAAC,iBAAiB,EAAE;YAC7B,IAAI,EAAE,GAAG;YACT,MAAM,EAAE,GAAG;YACX,QAAQ,EAAE,CAAC;YACX,gBAAgB,EAAE,EAAE;SACrB,CAAC,CAAA;QACF,MAAM,cAAc,GAAG,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAA;QAEnD,WAAW,CAAC,iBAAiB,EAAE;YAC7B,IAAI,EAAE,GAAG;YACT,MAAM,EAAE,GAAG;YACX,QAAQ,EAAE,CAAC;YACX,gBAAgB,EAAE,EAAE;SACrB,CAAC,CAAA;QACF,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,CAAA;QAEzD,UAAU,CAAC,WAAW,EAAE,CAAA;IAC1B,CAAC,CAAC,CAAA;AACJ,CAAC,CAAC,CAAA;AAEF,QAAQ,CAAC,sBAAsB,EAAE,GAAG,EAAE;IACpC,IAAI,CAAC,qDAAqD,EAAE,GAAG,EAAE;QAC/D,MAAM,UAAU,GAAG,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,SAAS,EAAE,SAAS,CAAC,CAAA;QAErD,iCAAiC;QACjC,QAAQ,CAAC,iBAAiB,EAAE,UAAU,EAAE;YACtC,MAAM,EAAE,GAAG;YACX,SAAS,EAAE,UAAU;SACtB,CAAC,CAAA;QACF,MAAM,cAAc,GAAG,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAA;QAEnD,4CAA4C;QAC5C,QAAQ,CAAC,iBAAiB,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,CAAA;QACpD,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,CAAA;QAEzD,UAAU,CAAC,WAAW,EAAE,CAAA;IAC1B,CAAC,CAAC,CAAA;AACJ,CAAC,CAAC,CAAA;AAEF,QAAQ,CAAC,oBAAoB,EAAE,GAAG,EAAE;IAClC,MAAM,YAAY,GAAG,kBAAkB,CAAC,qBAAqB,CAAC,CAAA;IAE9D,IAAI,CAAC,+BAA+B,EAAE,GAAG,EAAE;QACzC,MAAM,MAAM,GAAG,YAAY,CAAC;YAC1B,IAAI,EAAE,OAAO;YACb,MAAM,EAAE,KAAK;YACb,QAAQ,EAAE,CAAC;YACX,gBAAgB,EAAE,EAAE;SACrB,CAAC,CAAA;QACF,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;QACjC,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAA;IACjC,CAAC,CAAC,CAAA;IAEF,IAAI,CAAC,uCAAuC,EAAE,GAAG,EAAE;QACjD,4EAA4E;QAC5E,MAAM,CAAC,GAAG,EAAE,CAAC,YAAY,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,OAAO,CAClE,oBAAoB,CACrB,CAAA;IACH,CAAC,CAAC,CAAA;IAEF,IAAI,CAAC,kCAAkC,EAAE,GAAG,EAAE;QAC5C,MAAM,CAAC,GAAG,EAAE,CACV,YAAY,CAAC;YACX,IAAI,EAAE,OAAO;YACb,MAAM,EAAE,KAAK;YACb,+DAA+D;YAC/D,QAAQ,EAAE,KAAK;YACf,gBAAgB,EAAE,EAAE;SACrB,CAAC,CACH,CAAC,OAAO,CAAC,oBAAoB,CAAC,CAAA;IACjC,CAAC,CAAC,CAAA;IAEF,IAAI,CAAC,uCAAuC,EAAE,GAAG,EAAE;QACjD,MAAM,CAAC,GAAG,EAAE;QACV,4EAA4E;QAC5E,YAAY,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,EAAE,OAAO,EAAE,aAAa,EAAE,CAAC,CAC5D,CAAC,OAAO,CAAC,cAAc,CAAC,CAAA;IAC3B,CAAC,CAAC,CAAA;IAEF,IAAI,CAAC,qCAAqC,EAAE,GAAG,EAAE;QAC/C,MAAM,UAAU,GAAG,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,SAAS,EAAE,SAAS,CAAC,CAAA;QAErD,YAAY,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,QAAQ,EAAE,CAAC,EAAE,gBAAgB,EAAE,EAAE,EAAE,CAAC,CAAA;QAC3E,MAAM,cAAc,GAAG,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAA;QAEnD,YAAY,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,QAAQ,EAAE,CAAC,EAAE,gBAAgB,EAAE,EAAE,EAAE,CAAC,CAAA;QAC3E,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,CAAA;QAEzD,UAAU,CAAC,WAAW,EAAE,CAAA;IAC1B,CAAC,CAAC,CAAA;AACJ,CAAC,CAAC,CAAA"}

package/dist/schemas/cw20/index.d.ts

@@ -1,4 +1,5 @@
 import { cw20ExecuteSchema } from './execute.js';
+import { cw20InstantiateSchema } from './instantiate.js';
 import { cw20QuerySchema } from './query.js';
 import { cw20ResponseSchemas } from './responses.js';
 export declare const cw20: {
@@ -364,6 +365,156 @@ export declare const cw20: {
             };
         };
     };
+    readonly instantiate: {
+        readonly oneOf: readonly [{
+            readonly type: "object";
+            readonly required: readonly ["decimals", "initial_balances", "name", "symbol"];
+            readonly properties: {
+                readonly decimals: {
+                    readonly type: "integer";
+                    readonly format: "uint8";
+                    readonly minimum: 0;
+                };
+                readonly initial_balances: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly $ref: "#/definitions/Cw20Coin";
+                    };
+                };
+                readonly marketing: {
+                    readonly anyOf: readonly [{
+                        readonly $ref: "#/definitions/InstantiateMarketingInfo";
+                    }, {
+                        readonly type: "null";
+                    }];
+                };
+                readonly mint: {
+                    readonly anyOf: readonly [{
+                        readonly $ref: "#/definitions/MinterResponse";
+                    }, {
+                        readonly type: "null";
+                    }];
+                };
+                readonly name: {
+                    readonly type: "string";
+                };
+                readonly symbol: {
+                    readonly type: "string";
+                };
+            };
+            readonly additionalProperties: false;
+        }];
+        readonly definitions: {
+            readonly Cw20Coin: {
+                readonly type: "object";
+                readonly required: readonly ["address", "amount"];
+                readonly properties: {
+                    readonly address: {
+                        readonly type: "string";
+                    };
+                    readonly amount: {
+                        readonly $ref: "#/definitions/Uint128";
+                    };
+                };
+                readonly additionalProperties: false;
+            };
+            readonly EmbeddedLogo: {
+                readonly description: "This is used to store the logo on the blockchain in an accepted format. Enforce maximum size of 5KB on all variants.";
+                readonly oneOf: readonly [{
+                    readonly description: "Store the Logo as an SVG file. The content must conform to the spec at https://en.wikipedia.org/wiki/Scalable_Vector_Graphics (The contract should do some light-weight sanity-check validation)";
+                    readonly type: "object";
+                    readonly required: readonly ["svg"];
+                    readonly properties: {
+                        readonly svg: {
+                            readonly $ref: "#/definitions/Binary";
+                        };
+                    };
+                    readonly additionalProperties: false;
+                }, {
+                    readonly description: "Store the Logo as a PNG file. This will likely only support up to 64x64 or so within the 5KB limit.";
+                    readonly type: "object";
+                    readonly required: readonly ["png"];
+                    readonly properties: {
+                        readonly png: {
+                            readonly $ref: "#/definitions/Binary";
+                        };
+                    };
+                    readonly additionalProperties: false;
+                }];
+            };
+            readonly Binary: {
+                readonly description: "Binary is a wrapper around Vec<u8> to add base64 de/serialization with serde. It also adds some helper methods to help encode inline.\n\nThis is only needed as serde-json-{core,wasm} has a horrible encoding for Vec<u8>. See also <https://github.com/CosmWasm/cosmwasm/blob/main/docs/MESSAGE_TYPES.md>.";
+                readonly type: "string";
+            };
+            readonly InstantiateMarketingInfo: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly description: {
+                        readonly type: readonly ["string", "null"];
+                    };
+                    readonly logo: {
+                        readonly anyOf: readonly [{
+                            readonly $ref: "#/definitions/Logo";
+                        }, {
+                            readonly type: "null";
+                        }];
+                    };
+                    readonly marketing: {
+                        readonly type: readonly ["string", "null"];
+                    };
+                    readonly project: {
+                        readonly type: readonly ["string", "null"];
+                    };
+                };
+                readonly additionalProperties: false;
+            };
+            readonly Logo: {
+                readonly description: "This is used for uploading logo data, or setting it in InstantiateData";
+                readonly oneOf: readonly [{
+                    readonly description: "A reference to an externally hosted logo. Must be a valid HTTP or HTTPS URL.";
+                    readonly type: "object";
+                    readonly required: readonly ["url"];
+                    readonly properties: {
+                        readonly url: {
+                            readonly type: "string";
+                        };
+                    };
+                    readonly additionalProperties: false;
+                }, {
+                    readonly description: "Logo content stored on the blockchain. Enforce maximum size of 5KB on all variants";
+                    readonly type: "object";
+                    readonly required: readonly ["embedded"];
+                    readonly properties: {
+                        readonly embedded: {
+                            readonly $ref: "#/definitions/EmbeddedLogo";
+                        };
+                    };
+                    readonly additionalProperties: false;
+                }];
+            };
+            readonly MinterResponse: {
+                readonly type: "object";
+                readonly required: readonly ["minter"];
+                readonly properties: {
+                    readonly cap: {
+                        readonly anyOf: readonly [{
+                            readonly $ref: "#/definitions/Uint128";
+                        }, {
+                            readonly type: "null";
+                        }];
+                    };
+                    readonly minter: {
+                        readonly type: "string";
+                    };
+                };
+                readonly additionalProperties: false;
+            };
+            readonly Uint128: {
+                readonly description: "A thin wrapper around u128 that is using strings for JSON encoding/decoding, such that the full u128 range can be used for clients that convert JSON numbers to floats, like JavaScript and jq.\n\n# Examples\n\nUse `from` to create instances of this and `u128` to get the value out:\n\n``` # use cosmwasm_std::Uint128; let a = Uint128::from(123u128); assert_eq!(a.u128(), 123);\n\nlet b = Uint128::from(42u64); assert_eq!(b.u128(), 42);\n\nlet c = Uint128::from(70u32); assert_eq!(c.u128(), 70); ```";
+                readonly type: "string";
+            };
+        };
+    };
     readonly query: {
         readonly oneOf: readonly [{
             readonly description: "Returns the current balance of the given address, 0 if unset.";
@@ -901,5 +1052,5 @@ export declare const cw20: {
         };
     };
 };
-export { cw20ExecuteSchema, cw20QuerySchema, cw20ResponseSchemas };
+export { cw20ExecuteSchema, cw20InstantiateSchema, cw20QuerySchema, cw20ResponseSchemas, };
 //# sourceMappingURL=index.d.ts.map

package/dist/schemas/cw20/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/schemas/cw20/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAA;AAChD,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAC5C,OAAO,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAA;AAEpD,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAIP,CAAA;AAEV,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAE,mBAAmB,EAAE,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/schemas/cw20/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAA;AAChD,OAAO,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAA;AACxD,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAC5C,OAAO,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAA;AAEpD,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKP,CAAA;AAEV,OAAO,EACL,iBAAiB,EACjB,qBAAqB,EACrB,eAAe,EACf,mBAAmB,GACpB,CAAA"}

package/dist/schemas/cw20/index.js

@@ -1,10 +1,12 @@
 import { cw20ExecuteSchema } from './execute.js';
+import { cw20InstantiateSchema } from './instantiate.js';
 import { cw20QuerySchema } from './query.js';
 import { cw20ResponseSchemas } from './responses.js';
 export const cw20 = {
     execute: cw20ExecuteSchema,
+    instantiate: cw20InstantiateSchema,
     query: cw20QuerySchema,
     responses: cw20ResponseSchemas,
 };
-export { cw20ExecuteSchema, cw20QuerySchema, cw20ResponseSchemas };
+export { cw20ExecuteSchema, cw20InstantiateSchema, cw20QuerySchema, cw20ResponseSchemas, };
 //# sourceMappingURL=index.js.map

package/dist/schemas/cw20/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/schemas/cw20/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAA;AAChD,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAC5C,OAAO,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAA;AAEpD,MAAM,CAAC,MAAM,IAAI,GAAG;IAClB,OAAO,EAAE,iBAAiB;IAC1B,KAAK,EAAE,eAAe;IACtB,SAAS,EAAE,mBAAmB;CACtB,CAAA;AAEV,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAE,mBAAmB,EAAE,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/schemas/cw20/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAA;AAChD,OAAO,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAA;AACxD,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAA;AAC5C,OAAO,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAA;AAEpD,MAAM,CAAC,MAAM,IAAI,GAAG;IAClB,OAAO,EAAE,iBAAiB;IAC1B,WAAW,EAAE,qBAAqB;IAClC,KAAK,EAAE,eAAe;IACtB,SAAS,EAAE,mBAAmB;CACtB,CAAA;AAEV,OAAO,EACL,iBAAiB,EACjB,qBAAqB,EACrB,eAAe,EACf,mBAAmB,GACpB,CAAA"}