@pezkuwi/api-contract 16.5.5 → 16.5.6

package/Abi/index.js

@@ -0,0 +1,359 @@
+import { Option, TypeRegistry } from '@pezkuwi/types';
+import { TypeDefInfo } from '@pezkuwi/types-create';
+import { assertReturn, compactAddLength, compactStripLength, isBn, isNumber, isObject, isString, isUndefined, logger, stringCamelCase, stringify, u8aConcat, u8aToHex } from '@pezkuwi/util';
+import { convertVersions, enumVersions } from './toLatestCompatible.js';
+const l = logger('Abi');
+const PRIMITIVE_ALWAYS = ['AccountId', 'AccountId20', 'AccountIndex', 'Address', 'Balance'];
+function findMessage(list, messageOrId) {
+    const message = isNumber(messageOrId)
+        ? list[messageOrId]
+        : isString(messageOrId)
+            ? list.find(({ identifier }) => [identifier, stringCamelCase(identifier)].includes(messageOrId.toString()))
+            : messageOrId;
+    return assertReturn(message, () => `Attempted to call an invalid contract interface, ${stringify(messageOrId)}`);
+}
+function getMetadata(registry, json) {
+    // this is for V1, V2, V3
+    const vx = enumVersions.find((v) => isObject(json[v]));
+    // this was added in V4
+    const jsonVersion = json.version;
+    if (!vx && jsonVersion && !enumVersions.find((v) => v === `V${jsonVersion}`)) {
+        throw new Error(`Unable to handle version ${jsonVersion}`);
+    }
+    const metadata = registry.createType('ContractMetadata', vx
+        ? { [vx]: json[vx] }
+        : jsonVersion
+            ? { [`V${jsonVersion}`]: json }
+            : { V0: json });
+    const converter = convertVersions.find(([v]) => metadata[`is${v}`]);
+    if (!converter) {
+        throw new Error(`Unable to convert ABI with version ${metadata.type} to a supported version`);
+    }
+    const upgradedMetadata = converter[1](registry, metadata[`as${converter[0]}`]);
+    return upgradedMetadata;
+}
+function isRevive(json) {
+    const source = json['source'];
+    const version = json['version'];
+    const hasContractBinary = typeof source === 'object' &&
+        source !== null &&
+        'contract_binary' in source;
+    const hasVersion = typeof version === 'number' && version >= 6;
+    return hasContractBinary || hasVersion;
+}
+function parseJson(json, chainProperties) {
+    const registry = new TypeRegistry();
+    const revive = isRevive(json);
+    const typeName = revive ? 'ContractReviveProjectInfo' : 'ContractProjectInfo';
+    const info = registry.createType(typeName, json);
+    const metadata = getMetadata(registry, json);
+    const lookup = registry.createType('PortableRegistry', { types: metadata.types }, true);
+    // attach the lookup to the registry - now the types are known
+    registry.setLookup(lookup);
+    if (chainProperties) {
+        registry.setChainProperties(chainProperties);
+    }
+    // warm-up the actual type, pre-use
+    lookup.types.forEach(({ id }) => lookup.getTypeDef(id));
+    return [json, registry, metadata, info, revive];
+}
+/**
+ * @internal
+ * Determines if the given input value is a ContractTypeSpec
+ */
+function isTypeSpec(value) {
+    return !!value && value instanceof Map && !isUndefined(value.type) && !isUndefined(value.displayName);
+}
+/**
+ * @internal
+ * Determines if the given input value is an Option
+ */
+function isOption(value) {
+    return !!value && value instanceof Option;
+}
+export class Abi {
+    events;
+    constructors;
+    info;
+    json;
+    messages;
+    metadata;
+    registry;
+    environment = new Map();
+    isRevive;
+    constructor(abiJson, chainProperties) {
+        [this.json, this.registry, this.metadata, this.info, this.isRevive] = parseJson(isString(abiJson)
+            ? JSON.parse(abiJson)
+            : abiJson, chainProperties);
+        this.constructors = this.metadata.spec.constructors.map((spec, index) => this.#createMessage(spec, index, {
+            isConstructor: true,
+            isDefault: spec.default.isTrue,
+            isPayable: spec.payable.isTrue,
+            returnType: spec.returnType.isSome
+                ? this.registry.lookup.getTypeDef(spec.returnType.unwrap().type)
+                : null
+        }));
+        this.events = this.metadata.spec.events.map((_, index) => this.#createEvent(index));
+        this.messages = this.metadata.spec.messages.map((spec, index) => this.#createMessage(spec, index, {
+            isDefault: spec.default.isTrue,
+            isMutating: spec.mutates.isTrue,
+            isPayable: spec.payable.isTrue,
+            returnType: spec.returnType.isSome
+                ? this.registry.lookup.getTypeDef(spec.returnType.unwrap().type)
+                : null
+        }));
+        // NOTE See the rationale for having Option<...> values in the actual
+        // ContractEnvironmentV4 structure definition in interfaces/contractsAbi
+        // (Due to conversions, the fields may not exist)
+        for (const [key, opt] of this.metadata.spec.environment.entries()) {
+            if (isOption(opt)) {
+                if (opt.isSome) {
+                    const value = opt.unwrap();
+                    if (isBn(value)) {
+                        this.environment.set(key, value);
+                    }
+                    else if (isTypeSpec(value)) {
+                        this.environment.set(key, this.registry.lookup.getTypeDef(value.type));
+                    }
+                    else {
+                        throw new Error(`Invalid environment definition for ${key}:: Expected either Number or ContractTypeSpec`);
+                    }
+                }
+            }
+            else {
+                throw new Error(`Expected Option<*> definition for ${key} in ContractEnvironment`);
+            }
+        }
+    }
+    /**
+     * Warning: Unstable API, bound to change
+     */
+    decodeEvent(record) {
+        switch (this.metadata.version.toString()) {
+            // earlier version are hoisted to v4
+            case '4':
+                return this.#decodeEventV4(record);
+            case '5':
+                return this.#decodeEventV5(record);
+            // Latest
+            default:
+                return this.#decodeEventV6(record);
+        }
+    }
+    #decodeEventV6 = (record) => {
+        const topics = record.event.data[2];
+        // Try to match by signature topic (first topic)
+        const signatureTopic = topics[0];
+        const data = record.event.data[1];
+        if (signatureTopic) {
+            const event = this.events.find((e) => e.signatureTopic !== undefined && e.signatureTopic !== null && e.signatureTopic === signatureTopic.toHex());
+            // Early return if event found by signature topic
+            if (event) {
+                return event.fromU8a(data);
+            }
+        }
+        // If no event returned yet, it might be anonymous
+        const amountOfTopics = topics.length;
+        const potentialEvents = this.events.filter((e) => {
+            // event can't have a signature topic
+            if (e.signatureTopic !== null && e.signatureTopic !== undefined) {
+                return false;
+            }
+            // event should have same amount of indexed fields as emitted topics
+            const amountIndexed = e.args.filter((a) => a.indexed).length;
+            if (amountIndexed !== amountOfTopics) {
+                return false;
+            }
+            // If all conditions met, it's a potential event
+            return true;
+        });
+        if (potentialEvents.length === 1) {
+            return potentialEvents[0].fromU8a(data);
+        }
+        throw new Error('Unable to determine event');
+    };
+    #decodeEventV5 = (record) => {
+        // Find event by first topic, which potentially is the signature_topic
+        const signatureTopic = record.topics[0];
+        const data = record.event.data[1];
+        if (signatureTopic) {
+            const event = this.events.find((e) => e.signatureTopic !== undefined && e.signatureTopic !== null && e.signatureTopic === signatureTopic.toHex());
+            // Early return if event found by signature topic
+            if (event) {
+                return event.fromU8a(data);
+            }
+        }
+        // If no event returned yet, it might be anonymous
+        const amountOfTopics = record.topics.length;
+        const potentialEvents = this.events.filter((e) => {
+            // event can't have a signature topic
+            if (e.signatureTopic !== null && e.signatureTopic !== undefined) {
+                return false;
+            }
+            // event should have same amount of indexed fields as emitted topics
+            const amountIndexed = e.args.filter((a) => a.indexed).length;
+            if (amountIndexed !== amountOfTopics) {
+                return false;
+            }
+            // If all conditions met, it's a potential event
+            return true;
+        });
+        if (potentialEvents.length === 1) {
+            return potentialEvents[0].fromU8a(data);
+        }
+        throw new Error('Unable to determine event');
+    };
+    #decodeEventV4 = (record) => {
+        const data = record.event.data[1];
+        const index = data[0];
+        const event = this.events[index];
+        if (!event) {
+            throw new Error(`Unable to find event with index ${index}`);
+        }
+        return event.fromU8a(data.subarray(1));
+    };
+    /**
+     * Warning: Unstable API, bound to change
+     */
+    decodeConstructor(data) {
+        return this.#decodeMessage('message', this.constructors, data);
+    }
+    /**
+     * Warning: Unstable API, bound to change
+     */
+    decodeMessage(data) {
+        return this.#decodeMessage('message', this.messages, data);
+    }
+    findConstructor(constructorOrId) {
+        return findMessage(this.constructors, constructorOrId);
+    }
+    findMessage(messageOrId) {
+        return findMessage(this.messages, messageOrId);
+    }
+    #createArgs = (args, spec) => {
+        return args.map(({ label, type }, index) => {
+            try {
+                if (!isObject(type)) {
+                    throw new Error('Invalid type definition found');
+                }
+                const displayName = type.displayName.length
+                    ? type.displayName[type.displayName.length - 1].toString()
+                    : undefined;
+                const camelName = stringCamelCase(label);
+                if (displayName && PRIMITIVE_ALWAYS.includes(displayName)) {
+                    return {
+                        name: camelName,
+                        type: {
+                            info: TypeDefInfo.Plain,
+                            type: displayName
+                        }
+                    };
+                }
+                const typeDef = this.registry.lookup.getTypeDef(type.type);
+                return {
+                    name: camelName,
+                    type: displayName && !typeDef.type.startsWith(displayName)
+                        ? { displayName, ...typeDef }
+                        : typeDef
+                };
+            }
+            catch (error) {
+                l.error(`Error expanding argument ${index} in ${stringify(spec)}`);
+                throw error;
+            }
+        });
+    };
+    #createMessageParams = (args, spec) => {
+        return this.#createArgs(args, spec);
+    };
+    #createEventParams = (args, spec) => {
+        const params = this.#createArgs(args, spec);
+        return params.map((p, index) => ({ ...p, indexed: args[index].indexed.toPrimitive() }));
+    };
+    #createEvent = (index) => {
+        // TODO TypeScript would narrow this type to the correct version,
+        // but version is `Text` so I need to call `toString()` here,
+        // which breaks the type inference.
+        switch (this.metadata.version.toString()) {
+            case '4':
+                return this.#createEventV4(this.metadata.spec.events[index], index);
+            default:
+                return this.#createEventV5(this.metadata.spec.events[index], index);
+        }
+    };
+    #createEventV5 = (spec, index) => {
+        const args = this.#createEventParams(spec.args, spec);
+        const event = {
+            args,
+            docs: spec.docs.map((d) => d.toString()),
+            fromU8a: (data) => ({
+                args: this.#decodeArgs(args, data),
+                event
+            }),
+            identifier: [spec.module_path, spec.label].join('::'),
+            index,
+            signatureTopic: spec.signature_topic.isSome ? spec.signature_topic.unwrap().toHex() : null
+        };
+        return event;
+    };
+    #createEventV4 = (spec, index) => {
+        const args = this.#createEventParams(spec.args, spec);
+        const event = {
+            args,
+            docs: spec.docs.map((d) => d.toString()),
+            fromU8a: (data) => ({
+                args: this.#decodeArgs(args, data),
+                event
+            }),
+            identifier: spec.label.toString(),
+            index
+        };
+        return event;
+    };
+    #createMessage = (spec, index, add = {}) => {
+        const args = this.#createMessageParams(spec.args, spec);
+        const identifier = spec.label.toString();
+        const message = {
+            ...add,
+            args,
+            docs: spec.docs.map((d) => d.toString()),
+            fromU8a: (data) => ({
+                args: this.#decodeArgs(args, data),
+                message
+            }),
+            identifier,
+            index,
+            isDefault: spec.default.isTrue,
+            method: stringCamelCase(identifier),
+            path: identifier.split('::').map((s) => stringCamelCase(s)),
+            selector: spec.selector,
+            toU8a: (params) => this.#encodeMessageArgs(spec, args, params)
+        };
+        return message;
+    };
+    #decodeArgs = (args, data) => {
+        // for decoding we expect the input to be just the arg data, no selectors
+        // no length added (this allows use with events as well)
+        let offset = 0;
+        return args.map(({ type: { lookupName, type } }) => {
+            const value = this.registry.createType(lookupName || type, data.subarray(offset));
+            offset += value.encodedLength;
+            return value;
+        });
+    };
+    #decodeMessage = (type, list, data) => {
+        const [, trimmed] = compactStripLength(data);
+        const selector = trimmed.subarray(0, 4);
+        const message = list.find((m) => m.selector.eq(selector));
+        if (!message) {
+            throw new Error(`Unable to find ${type} with selector ${u8aToHex(selector)}`);
+        }
+        return message.fromU8a(trimmed.subarray(4));
+    };
+    #encodeMessageArgs = ({ label, selector }, args, data) => {
+        if (data.length !== args.length) {
+            throw new Error(`Expected ${args.length} arguments to contract message '${label.toString()}', found ${data.length}`);
+        }
+        return compactAddLength(u8aConcat(this.registry.createType('ContractSelector', selector).toU8a(), ...args.map(({ type: { lookupName, type } }, index) => this.registry.createType(lookupName || type, data[index]).toU8a())));
+    };
+}

package/Abi/toLatestCompatible.js

@@ -0,0 +1,30 @@
+import { v0ToV1 } from './toV1.js';
+import { v1ToV2 } from './toV2.js';
+import { v2ToV3 } from './toV3.js';
+import { v3ToV4 } from './toV4.js';
+export const enumVersions = ['V6', 'V5', 'V4', 'V3', 'V2', 'V1'];
+function createConverter(next, step) {
+    return (registry, input) => next(registry, step(registry, input));
+}
+export function v6ToLatestCompatible(_registry, v6) {
+    return v6;
+}
+export function v5ToLatestCompatible(_registry, v5) {
+    return v5;
+}
+export function v4ToLatestCompatible(_registry, v4) {
+    return v4;
+}
+export const v3ToLatestCompatible = /*#__PURE__*/ createConverter(v4ToLatestCompatible, v3ToV4);
+export const v2ToLatestCompatible = /*#__PURE__*/ createConverter(v3ToLatestCompatible, v2ToV3);
+export const v1ToLatestCompatible = /*#__PURE__*/ createConverter(v2ToLatestCompatible, v1ToV2);
+export const v0ToLatestCompatible = /*#__PURE__*/ createConverter(v1ToLatestCompatible, v0ToV1);
+export const convertVersions = [
+    ['V6', v6ToLatestCompatible],
+    ['V5', v5ToLatestCompatible],
+    ['V4', v4ToLatestCompatible],
+    ['V3', v3ToLatestCompatible],
+    ['V2', v2ToLatestCompatible],
+    ['V1', v1ToLatestCompatible],
+    ['V0', v0ToLatestCompatible]
+];

package/Abi/toV1.js

@@ -0,0 +1,21 @@
+import { convertSiV0toV1 } from '@pezkuwi/types';
+import { objectSpread } from '@pezkuwi/util';
+function v0ToV1Names(all) {
+    return all.map((e) => objectSpread({}, e, {
+        name: Array.isArray(e.name)
+            ? e.name
+            : [e.name]
+    }));
+}
+export function v0ToV1(registry, v0) {
+    if (!v0.metadataVersion.length) {
+        throw new Error('Invalid format for V0 (detected) contract metadata');
+    }
+    return registry.createType('ContractMetadataV1', objectSpread({}, v0, {
+        spec: objectSpread({}, v0.spec, {
+            constructors: v0ToV1Names(v0.spec.constructors),
+            messages: v0ToV1Names(v0.spec.messages)
+        }),
+        types: convertSiV0toV1(registry, v0.types)
+    }));
+}

package/Abi/toV2.js

@@ -0,0 +1,27 @@
+import { objectSpread } from '@pezkuwi/util';
+const ARG_TYPES = {
+    ContractConstructorSpec: 'ContractMessageParamSpecV2',
+    ContractEventSpec: 'ContractEventParamSpecV2',
+    ContractMessageSpec: 'ContractMessageParamSpecV2'
+};
+function v1ToV2Label(entry) {
+    return objectSpread({}, entry, {
+        label: Array.isArray(entry.name)
+            ? entry.name.join('::')
+            : entry.name
+    });
+}
+function v1ToV2Labels(registry, outType, all) {
+    return all.map((e) => registry.createType(`${outType}V2`, objectSpread(v1ToV2Label(e), {
+        args: e.args.map((a) => registry.createType(ARG_TYPES[outType], v1ToV2Label(a)))
+    })));
+}
+export function v1ToV2(registry, v1) {
+    return registry.createType('ContractMetadataV2', objectSpread({}, v1, {
+        spec: objectSpread({}, v1.spec, {
+            constructors: v1ToV2Labels(registry, 'ContractConstructorSpec', v1.spec.constructors),
+            events: v1ToV2Labels(registry, 'ContractEventSpec', v1.spec.events),
+            messages: v1ToV2Labels(registry, 'ContractMessageSpec', v1.spec.messages)
+        })
+    }));
+}

package/Abi/toV3.js

@@ -0,0 +1,10 @@
+import { objectSpread } from '@pezkuwi/util';
+export function v2ToV3(registry, v2) {
+    return registry.createType('ContractMetadataV3', objectSpread({}, v2, {
+        spec: objectSpread({}, v2.spec, {
+            constructors: v2.spec.constructors.map((c) => 
+            // V3 introduces the payable flag on constructors, for <V3, it is always true
+            registry.createType('ContractConstructorSpecV3', objectSpread({}, c, { payable: true })))
+        })
+    }));
+}

package/Abi/toV4.js

@@ -0,0 +1,10 @@
+import { objectSpread } from '@pezkuwi/util';
+export function v3ToV4(registry, v3) {
+    return registry.createType('ContractMetadataV4', objectSpread({}, v3, {
+        spec: objectSpread({}, v3.spec, {
+            constructors: v3.spec.constructors.map((c) => registry.createType('ContractConstructorSpecV4', objectSpread({}, c))),
+            messages: v3.spec.messages.map((m) => registry.createType('ContractMessageSpecV3', objectSpread({}, m)))
+        }),
+        version: registry.createType('Text', '4')
+    }));
+}

package/LICENSE

@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                    http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+  "License" shall mean the terms and conditions for use, reproduction,
+  and distribution as defined by Sections 1 through 9 of this document.
+
+  "Licensor" shall mean the copyright owner or entity authorized by
+  the copyright owner that is granting the License.
+
+  "Legal Entity" shall mean the union of the acting entity and all
+  other entities that control, are controlled by, or are under common
+  control with that entity. For the purposes of this definition,
+  "control" means (i) the power, direct or indirect, to cause the
+  direction or management of such entity, whether by contract or
+  otherwise, or (ii) ownership of fifty percent (50%) or more of the
+  outstanding shares, or (iii) beneficial ownership of such entity.
+
+  "You" (or "Your") shall mean an individual or Legal Entity
+  exercising permissions granted by this License.
+
+  "Source" form shall mean the preferred form for making modifications,
+  including but not limited to software source code, documentation
+  source, and configuration files.
+
+  "Object" form shall mean any form resulting from mechanical
+  transformation or translation of a Source form, including but
+  not limited to compiled object code, generated documentation,
+  and conversions to other media types.
+
+  "Work" shall mean the work of authorship, whether in Source or
+  Object form, made available under the License, as indicated by a
+  copyright notice that is included in or attached to the work
+  (an example is provided in the Appendix below).
+
+  "Derivative Works" shall mean any work, whether in Source or Object
+  form, that is based on (or derived from) the Work and for which the
+  editorial revisions, annotations, elaborations, or other modifications
+  represent, as a whole, an original work of authorship. For the purposes
+  of this License, Derivative Works shall not include works that remain
+  separable from, or merely link (or bind by name) to the interfaces of,
+  the Work and Derivative Works thereof.
+
+  "Contribution" shall mean any work of authorship, including
+  the original version of the Work and any modifications or additions
+  to that Work or Derivative Works thereof, that is intentionally
+  submitted to Licensor for inclusion in the Work by the copyright owner
+  or by an individual or Legal Entity authorized to submit on behalf of
+  the copyright owner. For the purposes of this definition, "submitted"
+  means any form of electronic, verbal, or written communication sent
+  to the Licensor or its representatives, including but not limited to
+  communication on electronic mailing lists, source code control systems,
+  and issue tracking systems that are managed by, or on behalf of, the
+  Licensor for the purpose of discussing and improving the Work, but
+  excluding communication that is conspicuously marked or otherwise
+  designated in writing by the copyright owner as "Not a Contribution."
+
+  "Contributor" shall mean Licensor and any individual or Legal Entity
+  on behalf of whom a Contribution has been received by Licensor and
+  subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+  this License, each Contributor hereby grants to You a perpetual,
+  worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+  copyright license to reproduce, prepare Derivative Works of,
+  publicly display, publicly perform, sublicense, and distribute the
+  Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+  this License, each Contributor hereby grants to You a perpetual,
+  worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+  (except as stated in this section) patent license to make, have made,
+  use, offer to sell, sell, import, and otherwise transfer the Work,
+  where such license applies only to those patent claims licensable
+  by such Contributor that are necessarily infringed by their
+  Contribution(s) alone or by combination of their Contribution(s)
+  with the Work to which such Contribution(s) was submitted. If You
+  institute patent litigation against any entity (including a
+  cross-claim or counterclaim in a lawsuit) alleging that the Work
+  or a Contribution incorporated within the Work constitutes direct
+  or contributory patent infringement, then any patent licenses
+  granted to You under this License for that Work shall terminate
+  as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+  Work or Derivative Works thereof in any medium, with or without
+  modifications, and in Source or Object form, provided that You
+  meet the following conditions:
+
+  (a) You must give any other recipients of the Work or
+      Derivative Works a copy of this License; and
+
+  (b) You must cause any modified files to carry prominent notices
+      stating that You changed the files; and
+
+  (c) You must retain, in the Source form of any Derivative Works
+      that You distribute, all copyright, patent, trademark, and
+      attribution notices from the Source form of the Work,
+      excluding those notices that do not pertain to any part of
+      the Derivative Works; and
+
+  (d) If the Work includes a "NOTICE" text file as part of its
+      distribution, then any Derivative Works that You distribute must
+      include a readable copy of the attribution notices contained
+      within such NOTICE file, excluding those notices that do not
+      pertain to any part of the Derivative Works, in at least one
+      of the following places: within a NOTICE text file distributed
+      as part of the Derivative Works; within the Source form or
+      documentation, if provided along with the Derivative Works; or,
+      within a display generated by the Derivative Works, if and
+      wherever such third-party notices normally appear. The contents
+      of the NOTICE file are for informational purposes only and
+      do not modify the License. You may add Your own attribution
+      notices within Derivative Works that You distribute, alongside
+      or as an addendum to the NOTICE text from the Work, provided
+      that such additional attribution notices cannot be construed
+      as modifying the License.
+
+  You may add Your own copyright statement to Your modifications and
+  may provide additional or different license terms and conditions
+  for use, reproduction, or distribution of Your modifications, or
+  for any such Derivative Works as a whole, provided Your use,
+  reproduction, and distribution of the Work otherwise complies with
+  the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+  any Contribution intentionally submitted for inclusion in the Work
+  by You to the Licensor shall be under the terms and conditions of
+  this License, without any additional terms or conditions.
+  Notwithstanding the above, nothing herein shall supersede or modify
+  the terms of any separate license agreement you may have executed
+  with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+  names, trademarks, service marks, or product names of the Licensor,
+  except as required for reasonable and customary use in describing the
+  origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+  agreed to in writing, Licensor provides the Work (and each
+  Contributor provides its Contributions) on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+  implied, including, without limitation, any warranties or conditions
+  of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+  PARTICULAR PURPOSE. You are solely responsible for determining the
+  appropriateness of using or redistributing the Work and assume any
+  risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+  whether in tort (including negligence), contract, or otherwise,
+  unless required by applicable law (such as deliberate and grossly
+  negligent acts) or agreed to in writing, shall any Contributor be
+  liable to You for damages, including any direct, indirect, special,
+  incidental, or consequential damages of any character arising as a
+  result of this License or out of the use or inability to use the
+  Work (including but not limited to damages for loss of goodwill,
+  work stoppage, computer failure or malfunction, or any and all
+  other commercial damages or losses), even if such Contributor
+  has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+  the Work or Derivative Works thereof, You may choose to offer,
+  and charge a fee for, acceptance of support, warranty, indemnity,
+  or other liability obligations and/or rights consistent with this
+  License. However, in accepting such obligations, You may act only
+  on Your own behalf and on Your sole responsibility, not on behalf
+  of any other Contributor, and only if You agree to indemnify,
+  defend, and hold each Contributor harmless for any liability
+  incurred by, or claims asserted against, such Contributor by reason
+  of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+  To apply the Apache License to your work, attach the following
+  boilerplate notice, with the fields enclosed by brackets "[]"
+  replaced with your own identifying information. (Don't include
+  the brackets!)  The text should be enclosed in the appropriate
+  comment syntax for the file format. We also recommend that a
+  file or class name and description of purpose be included on the
+  same "printed page" as the copyright notice for easier
+  identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/README.md

@@ -1,3 +1,3 @@
 # @pezkuwi/api-contract
 
-Interfaces to allow for the encoding and decoding of Substrate contract ABIs.
+Interfaces to allow for the encoding and decoding of Bizinikiwi contract ABIs.

package/augment.js

@@ -0,0 +1 @@
+import '@pezkuwi/api-augment';